target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void shouldOptionallyExcludeFieldsFromIncludedListChildFields() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("any item", 12.99)); serialization.from(order).include("items").exclude("items.price").serialize(); assertThat(result(), containsString("<items>")); assertThat(result(), containsString("<name>any item</name>")); assertThat(result(), not(containsString("12.99"))); assertThat(result(), containsString("</items>")); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldExcludeAllPrimitiveFields() { String expectedResult = "<order/>"; Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please"); serialization.from(order).excludeAll().serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void registerExtraParametersFromAcessedUrlWithGreedyParameters() throws SecurityException, NoSuchMethodException { DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{pathToFile*}"); control.fillIntoRequest("/clients/my/path/to/file", request); verify(request).setParameter("pathToFile", new String[] {"my/path/to/file"}); } | @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldExcludeAllPrimitiveParentFields() { String expectedResult = "<advancedOrder/>"; Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package"); serialization.from(order).excludeAll().serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldExcludeAllThanIncludeAndSerialize() { Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please"); serialization.from(order).excludeAll().include("price").serialize(); assertThat(result(), containsString("<order>")); assertThat(result(), containsString("<price>")); assertThat(result(), containsString("15.0")); assertThat(result(), containsString("</price>")); assertThat(result(), containsString("</order>")); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldAutomaticallyReadXStreamAnnotations() { WithAlias alias = new WithAlias(); alias.abc = "Duh!"; serialization.from(alias).serialize(); assertThat(result(), is("<withAlias><def>Duh!</def></withAlias>")); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldAutomaticallyReadXStreamAnnotationsForIncludedAttributes() { WithAlias alias = new WithAlias(); alias.abc = "Duh!"; WithAliasedAttribute attribute = new WithAliasedAttribute(); attribute.aliased = alias; serialization.from(attribute).include("aliased").serialize(); assertThat(result(), is("<withAliasedAttribute><aliased><def>Duh!</def></aliased></withAliasedAttribute>")); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldBeAbleToIncludeSubclassesFields() throws Exception { serialization.from(new B()).include("field2").serialize(); assertThat(result(), is("<b><field2/></b>")); } | @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | XStreamXMLSerialization implements XMLSerialization { @Override public <T> Serializer from(T object) { response.setContentType("application/xml"); return getSerializer().from(object); } protected XStreamXMLSerialization(); @Inject XStreamXMLSerialization(HttpServletResponse response, XStreamBuilder builder, Environment environment); @Override boolean accepts(String format); @Override XMLSerialization indented(); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldSerializeGenericClass() { String expectedResult = "{\"genericWrapper\":{\"entityList\":[{\"name\":\"washington botelho\"},{\"name\":\"washington botelho\"}],\"total\":2}}"; Collection<Client> entityList = new ArrayList<>(); entityList.add(new Client("washington botelho")); entityList.add(new Client("washington botelho")); GenericWrapper<Client> wrapper = new GenericWrapper<>(entityList, entityList.size()); serialization.from(wrapper).include("entityList").serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeAllBasicFields() { String expectedResult = "{\"order\":{\"price\":15.0,\"comments\":\"pack it nicely, please\"}}"; Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(order).serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldUseAlias() { String expectedResult = "{\"customOrder\":{\"price\":15.0,\"comments\":\"pack it nicely, please\"}}"; Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(order, "customOrder").serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeEnumFields() { Order order = new BasicOrder(new Client("guilherme silveira"), 15.0, "pack it nicely, please", Type.basic); serialization.from(order).serialize(); String result = result(); assertThat(result, containsString("\"type\":\"basic\"")); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeCollection() { String expectedResult = "{\"price\":15.0,\"comments\":\"pack it nicely, please\"}"; expectedResult += "," + expectedResult; expectedResult = "{\"list\":[" + expectedResult + "]}"; Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(Arrays.asList(order, order)).serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void registerExtraParametersFromAcessedUrlWithGreedyAndDottedParameters() throws SecurityException, NoSuchMethodException { DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{path.to.file*}"); control.fillIntoRequest("/clients/my/path/to/file", request); verify(request).setParameter("path.to.file", new String[] {"my/path/to/file"}); } | @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldSerializeCollectionWithPrefixTag() { String expectedResult = "{\"price\":15.0,\"comments\":\"pack it nicely, please\"}"; expectedResult += "," + expectedResult; expectedResult = "{\"orders\":[" + expectedResult + "]}"; Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(Arrays.asList(order, order), "orders").serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeNonPrimitiveFieldsFromACollection() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item( "name", 12.99)); serialization.from(Arrays.asList(order, order), "orders").exclude("price").serialize(); assertThat(result(), not(containsString("\"items\""))); assertThat(result(), not(containsString("name"))); assertThat(result(), not(containsString("\"price\""))); assertThat(result(), not(containsString("12.99"))); assertThat(result(), not(containsString("15.0"))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeOnlyOmmitedFields() { User user = new User("caelum", "pwd12345", new UserPrivateInfo("123.456.789-00", "+55 (11) 1111-1111")); serialization.from(user).recursive().serialize(); assertThat(result(), not(containsString("\"pwd12345\""))); assertThat(result(), not(containsString("password"))); assertThat(result(), containsString("\"caelum\"")); assertThat(result(), containsString("login")); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeOmmitedClasses() { User user = new User("caelum", "pwd12345", new UserPrivateInfo("123.456.789-00", "+55 (11) 1111-1111")); serialization.from(user).recursive().serialize(); assertThat(result(), not(containsString("info"))); assertThat(result(), not(containsString("cpf"))); assertThat(result(), not(containsString("phone"))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeParentFields() { Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package"); serialization.from(order).serialize(); assertThat(result(), containsString("\"notes\":\"complex package\"")); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeNonPrimitiveParentFields() { WithAdvanced advanced = new WithAdvanced(); advanced.order = new AdvancedOrder(new Client("john"), 15.0, "pack it nicely, please", "complex package"); serialization.from(advanced).include("order").serialize(); assertThat(result(), not(containsString("\"client\""))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeParentFields() { Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package"); serialization.from(order).exclude("comments").serialize(); assertThat(result(), not(containsString("\"comments\""))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldOptionallyExcludeFields() { String expectedResult = "{\"order\":{\"comments\":\"pack it nicely, please\"}}"; Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(order).exclude("price").serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldOptionallyIncludeFieldAndNotItsNonPrimitiveFields() { Order order = new Order(new Client("guilherme silveira", new Address("R. Vergueiro")), 15.0, "pack it nicely, please"); serialization.from(order).include("client").serialize(); assertThat(result(), containsString("\"name\":\"guilherme silveira\"")); assertThat(result(), not(containsString("R. Vergueiro"))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldOptionallyIncludeChildField() { Order order = new Order(new Client("guilherme silveira", new Address("R. Vergueiro")), 15.0, "pack it nicely, please"); serialization.from(order).include("client", "client.address").serialize(); assertThat(result(), containsString("\"street\":\"R. Vergueiro\"")); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void fillURLWithGreedyParameters() throws SecurityException, NoSuchMethodException { when(encodingHandler.getEncoding()).thenReturn(null); DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{pathToFile*}"); Method method = Controller.class.getDeclaredMethod("pathToFile", String.class); String filled = control.fillUri(nameProvider.parametersFor(method), "my/path/to/file"); assertThat(filled, is("/clients/my/path/to/file")); } | @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldOptionallyExcludeChildField() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(order).include("client").exclude("client.name").serialize(); assertThat(result(), containsString("\"client\"")); assertThat(result(), not(containsString("guilherme silveira"))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldOptionallyIncludeListChildFields() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item( "any item", 12.99)); serialization.from(order).include("items").serialize(); assertThat(result(), containsString("\"items\"")); assertThat(result(), containsString("\"name\":\"any item\"")); assertThat(result(), containsString("\"price\":12.99")); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeAllPrimitiveFieldsInACollection() { String expectedResult = "{\"list\":[{},{}]}"; List<Order> orders = new ArrayList<>(); orders.add(new Order(new Client("nykolas lima"), 15.0, "gift bags, please")); orders.add(new Order(new Client("Rafael Dipold"), 15.0, "gift bags, please")); serialization.from(orders).excludeAll().serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldOptionallyExcludeFieldsFromIncludedListChildFields() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item( "any item", 12.99)); serialization.from(order).include("items").exclude("items.price").serialize(); assertThat(result(), containsString("\"items\"")); assertThat(result(), containsString("\"name\":\"any item\"")); assertThat(result(), not(containsString("12.99"))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeCalendarTimeWithISO8601() { Client c = new Client("renan"); c.included = new GregorianCalendar(2012, 8, 3, 1, 5, 9); c.included.setTimeZone(TimeZone.getTimeZone("GMT-0300")); serialization.from(c).serialize(); String result = result(); String expectedResult = "{\"client\":{\"name\":\"renan\",\"included\":\"2012-09-03T01:05:09-03:00\"}}"; assertThat(result, is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeDateWithISO8601() { Date date = new GregorianCalendar(1988, 0, 25, 1, 30, 15).getTime(); serialization.from(date).serialize(); String expectedResult = "{\"date\":\"1988-01-25T01:30:15-0300\"}"; assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeAllPrimitiveFields() { String expectedResult = "{\"order\":{}}"; Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please"); serialization.from(order).excludeAll().serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeAllPrimitiveParentFields() { String expectedResult = "{\"advancedOrder\":{}}"; Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package"); serialization.from(order).excludeAll().serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldExcludeAllThanIncludeAndSerialize() { String expectedResult = "{\"order\":{\"price\":15.0}}"; Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please"); serialization.from(order).excludeAll().include("price").serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldSerializeWithCallback() { JSONPSerialization serialization = new GsonJSONPSerialization(response, extractor, builder, environment, new DefaultReflectionProvider()); String expectedResult = "calculate({\"order\":{\"price\":15.0}})"; Order order = new Order(new Client("nykolas lima"), 15.0, "gift bags, please"); serialization.withCallback("calculate").from(order).excludeAll().include("price").serialize(); assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void fillURLWithoutGreedyParameters() throws SecurityException, NoSuchMethodException { when(encodingHandler.getEncoding()).thenReturn(null); DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{pathToFile}"); Method method = Controller.class.getDeclaredMethod("pathToFile", String.class); String filled = control.fillUri(nameProvider.parametersFor(method), "my/path/to/file"); assertThat(filled, is("/clients/my/path/to/file")); } | @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldNotSerializeNullFieldsByDefault(){ Address address = new Address("Alameda street", null); serialization.from(address).serialize(); String expectedResult = "{\"address\":{\"street\":\"Alameda street\"}}"; assertThat(result(), is(equalTo(expectedResult))); } | @Override public <T> Serializer from(T object) { return from(object, null); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } | GsonJSONSerialization implements JSONSerialization { @Override public <T> Serializer from(T object) { return from(object, null); } protected GsonJSONSerialization(); @Inject GsonJSONSerialization(HttpServletResponse response, TypeNameExtractor extractor,
GsonSerializerBuilder builder, Environment environment, ReflectionProvider reflectionProvider); @Override boolean accepts(String format); @Override Serializer from(T object); @Override Serializer from(T object, String alias); @Override NoRootSerialization withoutRoot(); @Override JSONSerialization indented(); @Override JSONSerialization version(double versionNumber); @Override JSONSerialization serializeNulls(); } |
@Test public void shouldThrowExceptionWhenTypeIsNotADeserializer() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage(containsString("must implement Deserializer")); handler.handle(new DefaultBeanClass(NotADeserializer.class)); } | @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } protected DeserializesHandler(); @Inject DeserializesHandler(Deserializers deserializers); } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } protected DeserializesHandler(); @Inject DeserializesHandler(Deserializers deserializers); @SuppressWarnings("unchecked") void handle(@Observes @DeserializesQualifier BeanClass beanClass); } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } protected DeserializesHandler(); @Inject DeserializesHandler(Deserializers deserializers); @SuppressWarnings("unchecked") void handle(@Observes @DeserializesQualifier BeanClass beanClass); } |
@Test public void shouldRegisterTypesOnDeserializers() throws Exception { handler.handle(new DefaultBeanClass(MyDeserializer.class)); verify(deserializers).register(MyDeserializer.class); } | @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } protected DeserializesHandler(); @Inject DeserializesHandler(Deserializers deserializers); } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } protected DeserializesHandler(); @Inject DeserializesHandler(Deserializers deserializers); @SuppressWarnings("unchecked") void handle(@Observes @DeserializesQualifier BeanClass beanClass); } | DeserializesHandler { @SuppressWarnings("unchecked") public void handle(@Observes @DeserializesQualifier BeanClass beanClass) { Class<?> originalType = beanClass.getType(); checkArgument(Deserializer.class.isAssignableFrom(originalType), "%s must implement Deserializer", beanClass); deserializers.register((Class<? extends Deserializer>) originalType); } protected DeserializesHandler(); @Inject DeserializesHandler(Deserializers deserializers); @SuppressWarnings("unchecked") void handle(@Observes @DeserializesQualifier BeanClass beanClass); } |
@Test public void shouldThrowExceptionWhenThereIsNoDeserializerRegisteredForGivenContentType() throws Exception { assertNull(deserializers.deserializerFor("bogus content type", container)); } | @Override public Deserializer deserializerFor(String contentType, Container container) { if (deserializers.containsKey(contentType)) { return container.instanceFor(deserializers.get(contentType)); } return subpathDeserializerFor(contentType, container); } | DefaultDeserializers implements Deserializers { @Override public Deserializer deserializerFor(String contentType, Container container) { if (deserializers.containsKey(contentType)) { return container.instanceFor(deserializers.get(contentType)); } return subpathDeserializerFor(contentType, container); } } | DefaultDeserializers implements Deserializers { @Override public Deserializer deserializerFor(String contentType, Container container) { if (deserializers.containsKey(contentType)) { return container.instanceFor(deserializers.get(contentType)); } return subpathDeserializerFor(contentType, container); } } | DefaultDeserializers implements Deserializers { @Override public Deserializer deserializerFor(String contentType, Container container) { if (deserializers.containsKey(contentType)) { return container.instanceFor(deserializers.get(contentType)); } return subpathDeserializerFor(contentType, container); } @Override Deserializer deserializerFor(String contentType, Container container); @Override void register(Class<? extends Deserializer> type); } | DefaultDeserializers implements Deserializers { @Override public Deserializer deserializerFor(String contentType, Container container) { if (deserializers.containsKey(contentType)) { return container.instanceFor(deserializers.get(contentType)); } return subpathDeserializerFor(contentType, container); } @Override Deserializer deserializerFor(String contentType, Container container); @Override void register(Class<? extends Deserializer> type); } |
@Test public void allDeserializersMustBeAnnotatedWithDeserializes() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("You must annotate your deserializers with @Deserializes"); deserializers.register(NotAnnotatedDeserializer.class); } | @Override public void register(Class<? extends Deserializer> type) { Deserializes deserializes = type.getAnnotation(Deserializes.class); checkArgument(deserializes != null, "You must annotate your deserializers with @Deserializes"); for (String contentType : deserializes.value()) { deserializers.put(contentType, type); } } | DefaultDeserializers implements Deserializers { @Override public void register(Class<? extends Deserializer> type) { Deserializes deserializes = type.getAnnotation(Deserializes.class); checkArgument(deserializes != null, "You must annotate your deserializers with @Deserializes"); for (String contentType : deserializes.value()) { deserializers.put(contentType, type); } } } | DefaultDeserializers implements Deserializers { @Override public void register(Class<? extends Deserializer> type) { Deserializes deserializes = type.getAnnotation(Deserializes.class); checkArgument(deserializes != null, "You must annotate your deserializers with @Deserializes"); for (String contentType : deserializes.value()) { deserializers.put(contentType, type); } } } | DefaultDeserializers implements Deserializers { @Override public void register(Class<? extends Deserializer> type) { Deserializes deserializes = type.getAnnotation(Deserializes.class); checkArgument(deserializes != null, "You must annotate your deserializers with @Deserializes"); for (String contentType : deserializes.value()) { deserializers.put(contentType, type); } } @Override Deserializer deserializerFor(String contentType, Container container); @Override void register(Class<? extends Deserializer> type); } | DefaultDeserializers implements Deserializers { @Override public void register(Class<? extends Deserializer> type) { Deserializes deserializes = type.getAnnotation(Deserializes.class); checkArgument(deserializes != null, "You must annotate your deserializers with @Deserializes"); for (String contentType : deserializes.value()) { deserializers.put(contentType, type); } } @Override Deserializer deserializerFor(String contentType, Container container); @Override void register(Class<? extends Deserializer> type); } |
@Test public void shouldForwardToDefaultViewWithoutAlias() throws Exception { serialization.from(new Object()); verify(pageResult).defaultView(); } | @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } |
@Test public void shouldForwardToDefaultViewWithAlias() throws Exception { serialization.from(new Object(), "Abc"); verify(pageResult).defaultView(); } | @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } |
@Test public void shouldIncludeOnResultWithoutAlias() throws Exception { Object object = new Object(); when(extractor.nameFor(Object.class)).thenReturn("obj"); serialization.from(object); verify(result).include("obj", object); } | @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } |
@Test public void shouldIncludeOnResultWithAlias() throws Exception { Object object = new Object(); serialization.from(object, "Abc"); verify(result).include("Abc", object); } | @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } |
@Test public void shouldReturnAnIgnoringSerializerWithoutAlias() throws Exception { Serializer serializer = serialization.from(new Object()); assertThat(serializer, is(instanceOf(IgnoringSerializer.class))); } | @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } |
@Test public void whenNoParameterPatternsAreGivenShouldMatchAnything() throws Exception { ParametersControl control = new DefaultParametersControl("/any/{aParameter}/what", Collections.<String,String>emptyMap(), converters, evaluator,encodingHandler); assertTrue(control.matches("/any/ICanPutAnythingInHere/what")); } | @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldReturnAnIgnoringSerializerWithAlias() throws Exception { Serializer serializer = serialization.from(new Object(), "Abc"); assertThat(serializer, is(instanceOf(IgnoringSerializer.class))); } | @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } | HTMLSerialization implements Serialization { @Override public <T> Serializer from(T object, String alias) { result.include(alias, object); result.use(page()).defaultView(); return new IgnoringSerializer(); } protected HTMLSerialization(); @Inject HTMLSerialization(Result result, TypeNameExtractor extractor); @Override boolean accepts(String format); @Override Serializer from(T object, String alias); @Override Serializer from(T object); } |
@Test public void shouldAcceptAlways() { assertTrue(interceptor.accepts(null)); } | @Override public boolean accepts(ControllerMethod method) { return true; } | FlashInterceptor implements Interceptor { @Override public boolean accepts(ControllerMethod method) { return true; } } | FlashInterceptor implements Interceptor { @Override public boolean accepts(ControllerMethod method) { return true; } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public boolean accepts(ControllerMethod method) { return true; } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public boolean accepts(ControllerMethod method) { return true; } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void shouldDoNothingWhenThereIsNoFlashParameters() throws Exception { when(session.getAttribute(FLASH_INCLUDED_PARAMETERS)).thenReturn(null); interceptor.intercept(stack, null, null); verifyZeroInteractions(result); } | @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void shouldAddAllFlashParametersToResult() throws Exception { when(session.getAttribute(FLASH_INCLUDED_PARAMETERS)).thenReturn(singletonMap("Abc", 1002)); interceptor.intercept(stack, null, null); verify(result).include("Abc", 1002); } | @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void shouldRemoveFlashIncludedParameters() throws Exception { when(session.getAttribute(FLASH_INCLUDED_PARAMETERS)).thenReturn(singletonMap("Abc", 1002)); interceptor.intercept(stack, null, null); verify(session).removeAttribute(FLASH_INCLUDED_PARAMETERS); } | @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void shouldIncludeFlashParametersWhenARedirectHappens() throws Exception { Map<String, Object> parameters = Collections.<String, Object>singletonMap("Abc", 1002); when(result.included()).thenReturn(parameters); when(session.getAttribute(FLASH_INCLUDED_PARAMETERS)).thenReturn(null); interceptor.intercept(stack, null, null); response.sendRedirect("Anything"); verify(session).setAttribute(FLASH_INCLUDED_PARAMETERS, parameters); } | @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void shouldNotIncludeFlashParametersWhenThereIsNoIncludedParameter() throws Exception { Map<String, Object> parameters = Collections.emptyMap(); when(result.included()).thenReturn(parameters); when(session.getAttribute(FLASH_INCLUDED_PARAMETERS)).thenReturn(null); interceptor.intercept(stack, null, null); response.sendRedirect("Anything"); verify(session, never()).setAttribute(anyString(), anyObject()); } | @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void shouldNotCrashWhenSessionIsInvalid() throws Exception { Map<String, Object> parameters = Collections.<String, Object>singletonMap("Abc", 1002); when(result.included()).thenReturn(parameters); doThrow(new IllegalStateException()).when(session).setAttribute(FLASH_INCLUDED_PARAMETERS, parameters); when(session.getAttribute(FLASH_INCLUDED_PARAMETERS)).thenReturn(null); interceptor.intercept(stack, null, null); response.sendRedirect("Anything"); } | @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } | FlashInterceptor implements Interceptor { @Override public void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance) throws InterceptionException { Map<String, Object> parameters = (Map<String, Object>) session.getAttribute(FLASH_INCLUDED_PARAMETERS); if (parameters != null) { parameters = new HashMap<>(parameters); session.removeAttribute(FLASH_INCLUDED_PARAMETERS); for (Entry<String, Object> parameter : parameters.entrySet()) { result.include(parameter.getKey(), parameter.getValue()); } } response.addRedirectListener(new RedirectListener() { @Override public void beforeRedirect() { Map<String, Object> included = result.included(); if (!included.isEmpty()) { try { session.setAttribute(FLASH_INCLUDED_PARAMETERS, new HashMap<>(included)); } catch (IllegalStateException e) { LOGGER.warn("HTTP Session was invalidated. It is not possible to include " + "Result parameters on Flash Scope", e); } } } }); stack.next(method, controllerInstance); } protected FlashInterceptor(); @Inject FlashInterceptor(HttpSession session, Result result, MutableResponse response); @Override boolean accepts(ControllerMethod method); @Override void intercept(InterceptorStack stack, ControllerMethod method, Object controllerInstance); } |
@Test public void mustNotUseInternalAcceptsAndCustomAccepts(){ exception.expect(IllegalStateException.class); exception.expectMessage("Interceptor class " + InternalAndCustomAcceptsInterceptor.class.getName() + " must declare internal accepts or custom, not both"); Class<?> type = InternalAndCustomAcceptsInterceptor.class; List<Method> methods = stepInvoker.findAllMethods(type); validationRule.validate(type, methods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shouldValidateIfConstainsOnlyInternalAccepts(){ Class<?> type = InternalAcceptsInterceptor.class; List<Method> methods = stepInvoker.findAllMethods(type); validationRule.validate(type, methods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void whenParameterPatternsAreGivenShouldMatchAccordingToGivenPatterns() throws Exception { ParametersControl control = new DefaultParametersControl("/any/{aParameter}/what", Collections.singletonMap("aParameter", "aaa\\d{3}bbb"), converters, evaluator,encodingHandler); assertFalse(control.matches("/any/ICantPutAnythingInHere/what")); assertFalse(control.matches("/any/aaa12bbb/what")); assertTrue(control.matches("/any/aaa123bbb/what")); } | @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public boolean matches(String uri) { return pattern.matcher(uri).matches(); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldValidateIfConstainsOnlyCustomAccepts(){ Class<?> type = CustomAcceptsInterceptor.class; List<Method> methods = stepInvoker.findAllMethods(type); validationRule.validate(type, methods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | CustomAndInternalAcceptsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); List<Annotation> constraints = getCustomAcceptsAnnotations(originalType); checkState(accepts == null || constraints.isEmpty(), "Interceptor %s must declare internal accepts or custom, not both.", originalType); } protected CustomAndInternalAcceptsValidationRule(); @Inject CustomAndInternalAcceptsValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shoulThrowExceptionIfInterceptorDontHaveAnyCallableMethod() { exception.expect(InterceptionException.class); exception.expectMessage("Interceptor " + SimpleInterceptor.class.getCanonicalName() +" must declare at least one method whith @AfterCall, @AroundCall or @BeforeCall annotation"); Class<?> type = SimpleInterceptor.class; List<Method> allMethods = stepInvoker.findAllMethods(type); new NoInterceptMethodsValidationRule(stepInvoker).validate(type, allMethods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } protected NoInterceptMethodsValidationRule(); @Inject NoInterceptMethodsValidationRule(StepInvoker stepInvoker); } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } protected NoInterceptMethodsValidationRule(); @Inject NoInterceptMethodsValidationRule(StepInvoker stepInvoker); @Override void validate(Class<?> originalType, List<Method> methods); } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } protected NoInterceptMethodsValidationRule(); @Inject NoInterceptMethodsValidationRule(StepInvoker stepInvoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shoulWorksFineIfInterceptorHaveAtLeastOneCallableMethod() { Class<?> type = SimpleInterceptorWithCallableMethod.class; List<Method> allMethods = stepInvoker.findAllMethods(type); new NoInterceptMethodsValidationRule(stepInvoker).validate(type, allMethods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } protected NoInterceptMethodsValidationRule(); @Inject NoInterceptMethodsValidationRule(StepInvoker stepInvoker); } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } protected NoInterceptMethodsValidationRule(); @Inject NoInterceptMethodsValidationRule(StepInvoker stepInvoker); @Override void validate(Class<?> originalType, List<Method> methods); } | NoInterceptMethodsValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { boolean hasAfterMethod = hasAnnotatedMethod(AfterCall.class, originalType, methods); boolean hasAroundMethod = hasAnnotatedMethod(AroundCall.class, originalType, methods); boolean hasBeforeMethod = hasAnnotatedMethod(BeforeCall.class, originalType, methods); if (!hasAfterMethod && !hasAroundMethod && !hasBeforeMethod) { throw new InterceptionException(format("Interceptor %s must " + "declare at least one method whith @AfterCall, @AroundCall " + "or @BeforeCall annotation", originalType.getCanonicalName())); } } protected NoInterceptMethodsValidationRule(); @Inject NoInterceptMethodsValidationRule(StepInvoker stepInvoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shouldValidateWithOne() throws Exception { InstanceContainer container = new InstanceContainer(withAnnotationAcceptor); CustomAcceptsVerifier verifier = new CustomAcceptsVerifier(container); assertTrue(verifier.isValid(interceptor, controllerMethod, controllerInstance, constraints)); } | @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); @SuppressWarnings({ "rawtypes", "unchecked" }) boolean isValid(Object interceptor, ControllerMethod controllerMethod,
ControllerInstance controllerInstance, List<Annotation> constraints); static List<Annotation> getCustomAcceptsAnnotations(Class<?> clazz); } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); @SuppressWarnings({ "rawtypes", "unchecked" }) boolean isValid(Object interceptor, ControllerMethod controllerMethod,
ControllerInstance controllerInstance, List<Annotation> constraints); static List<Annotation> getCustomAcceptsAnnotations(Class<?> clazz); } |
@Test public void shouldValidateWithTwoOrMore() throws Exception { InstanceContainer container = new InstanceContainer(withAnnotationAcceptor,packagesAcceptor); CustomAcceptsVerifier verifier = new CustomAcceptsVerifier(container); assertTrue(verifier.isValid(interceptor, controllerMethod, controllerInstance, constraints)); } | @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); @SuppressWarnings({ "rawtypes", "unchecked" }) boolean isValid(Object interceptor, ControllerMethod controllerMethod,
ControllerInstance controllerInstance, List<Annotation> constraints); static List<Annotation> getCustomAcceptsAnnotations(Class<?> clazz); } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); @SuppressWarnings({ "rawtypes", "unchecked" }) boolean isValid(Object interceptor, ControllerMethod controllerMethod,
ControllerInstance controllerInstance, List<Annotation> constraints); static List<Annotation> getCustomAcceptsAnnotations(Class<?> clazz); } |
@Test public void shouldEndProcessIfOneIsInvalid() throws Exception { InstanceContainer container = new InstanceContainer(withAnnotationAcceptor,packagesAcceptor); CustomAcceptsVerifier verifier = new CustomAcceptsVerifier(container); when(withAnnotationAcceptor.validate(controllerMethod, controllerInstance)).thenReturn(false); verify(packagesAcceptor, never()).validate(controllerMethod, controllerInstance); assertFalse(verifier.isValid(interceptor, controllerMethod, controllerInstance, constraints)); } | @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); @SuppressWarnings({ "rawtypes", "unchecked" }) boolean isValid(Object interceptor, ControllerMethod controllerMethod,
ControllerInstance controllerInstance, List<Annotation> constraints); static List<Annotation> getCustomAcceptsAnnotations(Class<?> clazz); } | CustomAcceptsVerifier { @SuppressWarnings({ "rawtypes", "unchecked" }) public boolean isValid(Object interceptor, ControllerMethod controllerMethod, ControllerInstance controllerInstance, List<Annotation> constraints) { for (Annotation annotation : constraints) { AcceptsConstraint constraint = annotation.annotationType().getAnnotation(AcceptsConstraint.class); Class<? extends AcceptsValidator<?>> validatorClass = constraint.value(); AcceptsValidator validator = container.instanceFor(validatorClass); validator.initialize(annotation); if (!validator.validate(controllerMethod, controllerInstance)) { return false; } } return true; } protected CustomAcceptsVerifier(); @Inject CustomAcceptsVerifier(Container container); @SuppressWarnings({ "rawtypes", "unchecked" }) boolean isValid(Object interceptor, ControllerMethod controllerMethod,
ControllerInstance controllerInstance, List<Annotation> constraints); static List<Annotation> getCustomAcceptsAnnotations(Class<?> clazz); } |
@Test public void shouldAlwaysCallAround() { AlwaysAcceptsAspectInterceptor interceptor = spy(new AlwaysAcceptsAspectInterceptor()); AspectStyleInterceptorHandler handler = newAspectStyleInterceptorHandler( AlwaysAcceptsAspectInterceptor.class, interceptor); handler.execute(stack, controllerMethod, currentController); verify(interceptor).intercept(Mockito.same(stack), Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldInvokeUsingBeforeAndAfter() { AlwaysAcceptsAspectInterceptor interceptor = spy(new AlwaysAcceptsAspectInterceptor()); AspectStyleInterceptorHandler handler = newAspectStyleInterceptorHandler( AlwaysAcceptsAspectInterceptor.class, interceptor); handler.execute(stack, controllerMethod, currentController); InOrder order = inOrder(interceptor); order.verify(interceptor).begin(); order.verify(interceptor).intercept( Mockito.same(stack), Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); order.verify(interceptor).after(); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldInvokeIfAccepts() { AcceptsInterceptor acceptsInterceptor = spy(new AcceptsInterceptor(true)); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( AcceptsInterceptor.class, acceptsInterceptor); aspectHandler.execute(stack, controllerMethod, currentController); InOrder order = inOrder(acceptsInterceptor); order.verify(acceptsInterceptor).accepts(controllerMethod); order.verify(acceptsInterceptor).before(); order.verify(acceptsInterceptor).around( Mockito.same(stack), Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); order.verify(acceptsInterceptor).after(); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldNotInvokeIfDoesNotAccept() { AcceptsInterceptor acceptsInterceptor = spy(new AcceptsInterceptor( false)); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( AcceptsInterceptor.class, acceptsInterceptor); aspectHandler.execute(stack, controllerMethod, currentController); verify(acceptsInterceptor).accepts(controllerMethod); verify(acceptsInterceptor, never()).before(); verify(acceptsInterceptor, never()).around(Mockito.same(stack), Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); verify(acceptsInterceptor, never()).after(); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldDecodeUriParameters() throws Exception { DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{name}"); control.fillIntoRequest("/clients/Joao+Leno", request); verify(request).setParameter("name", "Joao Leno"); control.fillIntoRequest("/clients/Paulo%20Macartinei", request); verify(request).setParameter("name", "Paulo Macartinei"); } | @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public void fillIntoRequest(String uri, MutableRequest request) { Matcher m = pattern.matcher(uri); m.matches(); for (int i = 1; i <= m.groupCount(); i++) { String name = parameters.get(i - 1); try { request.setParameter(name, URLDecoder.decode(m.group(i), encodingHandler.getEncoding())); } catch (UnsupportedEncodingException e) { logger.error("Error when decoding url parameters"); } } } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldBypassWebsocketRequests() throws Exception { HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); FilterChain chain = mock(FilterChain.class); when(request.getHeader("Upgrade")).thenReturn("Websocket"); vRaptor.doFilter(request, response, chain); verify(request).getHeader("Upgrade"); verify(chain).doFilter(request, response); verifyNoMoreInteractions(request, response); } | @Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { validateServletEnvironment(req, res); final HttpServletRequest baseRequest = (HttpServletRequest) req; final HttpServletResponse baseResponse = (HttpServletResponse) res; if (isWebsocketRequest(baseRequest)) { chain.doFilter(req, res); return; } if (staticHandler.requestingStaticFile(baseRequest)) { staticHandler.deferProcessingToContainer(chain, baseRequest, baseResponse); } else { logger.trace("VRaptor received a new request {}", req); try { encodingHandler.setEncoding(baseRequest, baseResponse); RequestStarted requestStarted = requestStartedFactory.createEvent(baseRequest, baseResponse, chain); cdiRequestFactories.setRequest(requestStarted); requestStartedEvent.fire(requestStarted); } catch (ApplicationLogicException e) { throw new ServletException(e.getMessage(), e.getCause()); } logger.debug("VRaptor ended the request"); } } | VRaptor implements Filter { @Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { validateServletEnvironment(req, res); final HttpServletRequest baseRequest = (HttpServletRequest) req; final HttpServletResponse baseResponse = (HttpServletResponse) res; if (isWebsocketRequest(baseRequest)) { chain.doFilter(req, res); return; } if (staticHandler.requestingStaticFile(baseRequest)) { staticHandler.deferProcessingToContainer(chain, baseRequest, baseResponse); } else { logger.trace("VRaptor received a new request {}", req); try { encodingHandler.setEncoding(baseRequest, baseResponse); RequestStarted requestStarted = requestStartedFactory.createEvent(baseRequest, baseResponse, chain); cdiRequestFactories.setRequest(requestStarted); requestStartedEvent.fire(requestStarted); } catch (ApplicationLogicException e) { throw new ServletException(e.getMessage(), e.getCause()); } logger.debug("VRaptor ended the request"); } } } | VRaptor implements Filter { @Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { validateServletEnvironment(req, res); final HttpServletRequest baseRequest = (HttpServletRequest) req; final HttpServletResponse baseResponse = (HttpServletResponse) res; if (isWebsocketRequest(baseRequest)) { chain.doFilter(req, res); return; } if (staticHandler.requestingStaticFile(baseRequest)) { staticHandler.deferProcessingToContainer(chain, baseRequest, baseResponse); } else { logger.trace("VRaptor received a new request {}", req); try { encodingHandler.setEncoding(baseRequest, baseResponse); RequestStarted requestStarted = requestStartedFactory.createEvent(baseRequest, baseResponse, chain); cdiRequestFactories.setRequest(requestStarted); requestStartedEvent.fire(requestStarted); } catch (ApplicationLogicException e) { throw new ServletException(e.getMessage(), e.getCause()); } logger.debug("VRaptor ended the request"); } } } | VRaptor implements Filter { @Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { validateServletEnvironment(req, res); final HttpServletRequest baseRequest = (HttpServletRequest) req; final HttpServletResponse baseResponse = (HttpServletResponse) res; if (isWebsocketRequest(baseRequest)) { chain.doFilter(req, res); return; } if (staticHandler.requestingStaticFile(baseRequest)) { staticHandler.deferProcessingToContainer(chain, baseRequest, baseResponse); } else { logger.trace("VRaptor received a new request {}", req); try { encodingHandler.setEncoding(baseRequest, baseResponse); RequestStarted requestStarted = requestStartedFactory.createEvent(baseRequest, baseResponse, chain); cdiRequestFactories.setRequest(requestStarted); requestStartedEvent.fire(requestStarted); } catch (ApplicationLogicException e) { throw new ServletException(e.getMessage(), e.getCause()); } logger.debug("VRaptor ended the request"); } } @Override void init(FilterConfig cfg); @Override void doFilter(ServletRequest req, ServletResponse res, FilterChain chain); @Override void destroy(); } | VRaptor implements Filter { @Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { validateServletEnvironment(req, res); final HttpServletRequest baseRequest = (HttpServletRequest) req; final HttpServletResponse baseResponse = (HttpServletResponse) res; if (isWebsocketRequest(baseRequest)) { chain.doFilter(req, res); return; } if (staticHandler.requestingStaticFile(baseRequest)) { staticHandler.deferProcessingToContainer(chain, baseRequest, baseResponse); } else { logger.trace("VRaptor received a new request {}", req); try { encodingHandler.setEncoding(baseRequest, baseResponse); RequestStarted requestStarted = requestStartedFactory.createEvent(baseRequest, baseResponse, chain); cdiRequestFactories.setRequest(requestStarted); requestStartedEvent.fire(requestStarted); } catch (ApplicationLogicException e) { throw new ServletException(e.getMessage(), e.getCause()); } logger.debug("VRaptor ended the request"); } } @Override void init(FilterConfig cfg); @Override void doFilter(ServletRequest req, ServletResponse res, FilterChain chain); @Override void destroy(); static final String VERSION; } |
@Test public void shouldInvokeAcceptsWithoutArgs() { AcceptsWithoutArgsInterceptor acceptsWithoutArgsInterceptor = spy(new AcceptsWithoutArgsInterceptor()); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( AcceptsWithoutArgsInterceptor.class, acceptsWithoutArgsInterceptor); aspectHandler.execute(stack, controllerMethod, currentController); InOrder order = inOrder(acceptsWithoutArgsInterceptor); order.verify(acceptsWithoutArgsInterceptor).accepts(); order.verify(acceptsWithoutArgsInterceptor).before(); order.verify(acceptsWithoutArgsInterceptor).around( Mockito.same(stack), Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); order.verify(acceptsWithoutArgsInterceptor).after(); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldInvokeAroundWithSimpleStack() { ExampleOfSimpleStackInterceptor simpleStackInterceptor = spy(new ExampleOfSimpleStackInterceptor()); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( ExampleOfSimpleStackInterceptor.class, simpleStackInterceptor); aspectHandler.execute(stack, controllerMethod, currentController); verify(simpleStackInterceptor).around( Mockito.any(SimpleInterceptorStack.class)); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldInvokeNextIfNotAccepts() throws Exception { AcceptsInterceptor interceptor = spy(new AcceptsInterceptor(false)); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( AcceptsInterceptor.class, interceptor); aspectHandler.execute(stack, controllerMethod, null); verify(interceptor, never()).around( Mockito.any(InterceptorStack.class), Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); verify(stack).next(Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class)); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldNotInvokeIfDoesNotHaveAround() throws Exception { WithoutAroundInterceptor interceptor = spy(new WithoutAroundInterceptor()); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( WithoutAroundInterceptor.class, interceptor); aspectHandler.execute(stack, controllerMethod, null); verify(simpleInterceptorStack).next(); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldAcceptCustomizedAccepts() throws Exception { InterceptorWithCustomizedAccepts interceptor = new InterceptorWithCustomizedAccepts(); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( InterceptorWithCustomizedAccepts.class, interceptor, withAnnotationAcceptor); when(withAnnotationAcceptor.validate(Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class))).thenReturn(true); aspectHandler.execute(stack, controllerMethod, new MethodLevelAcceptsController()); assertTrue(interceptor.isBeforeCalled()); assertTrue(interceptor.isInterceptCalled()); assertTrue(interceptor.isAfterCalled()); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldNotAcceptCustomizedAccepts() throws Exception { InterceptorWithCustomizedAccepts interceptor = new InterceptorWithCustomizedAccepts(); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( InterceptorWithCustomizedAccepts.class, interceptor,withAnnotationAcceptor); when(withAnnotationAcceptor.validate(Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class))).thenReturn(false); aspectHandler.execute(stack, controllerMethod, new MethodLevelAcceptsController()); assertFalse(interceptor.isBeforeCalled()); assertFalse(interceptor.isInterceptCalled()); assertFalse(interceptor.isAfterCalled()); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldInvokeCustomAcceptsFailCallback() { InterceptorWithCustomizedAccepts interceptor = spy(new InterceptorWithCustomizedAccepts()); AspectStyleInterceptorHandler aspectHandler = newAspectStyleInterceptorHandler( InterceptorWithCustomizedAccepts.class, interceptor, withAnnotationAcceptor); when(withAnnotationAcceptor.validate(Mockito.same(controllerMethod), Mockito.any(ControllerInstance.class))).thenReturn(false); aspectHandler.execute(stack, controllerMethod, aspectHandler); verify(interceptor).customAcceptsFailCallback(); } | @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } | AspectStyleInterceptorHandler implements InterceptorHandler { @Override public void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController) { Object interceptor = container.instanceFor(interceptorClass); logger.debug("Invoking interceptor {}", interceptor.getClass().getSimpleName()); List<Annotation> customAccepts = customAcceptsExecutor.getCustomAccepts(interceptor); if (customAccepts(interceptor, customAccepts) || internalAccepts(interceptor, customAccepts)) { interceptorExecutor.execute(interceptor, beforeMethod); interceptorExecutor.executeAround(interceptor, aroundMethod); interceptorExecutor.execute(interceptor, afterMethod); } else { stack.next(controllerMethod, currentController); } } AspectStyleInterceptorHandler(Class<?> interceptorClass, StepInvoker stepInvoker,
Container container, CustomAcceptsExecutor customAcceptsExecutor,
InterceptorAcceptsExecutor acceptsExecutor, InterceptorExecutor interceptorExecutor); @Override void execute(InterceptorStack stack, ControllerMethod controllerMethod, Object currentController); @Override String toString(); } |
@Test public void shouldDecapitalizeSomeCharsUntilItFindsOneUppercased() throws NoSuchMethodException { Assert.assertEquals("urlClassLoader",extractor.nameFor(URLClassLoader.class)); Assert.assertEquals("bigDecimal",extractor.nameFor(BigDecimal.class)); Assert.assertEquals("string",extractor.nameFor(String.class)); Assert.assertEquals("aClass",extractor.nameFor(AClass.class)); Assert.assertEquals("url",extractor.nameFor(URL.class)); } | @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } |
@Test public void shouldDecapitalizeSomeCharsUntilItFindsOneUppercasedForListsAndArrays() throws NoSuchMethodException, SecurityException, NoSuchFieldException { Assert.assertEquals("stringList",extractor.nameFor(getField("strings"))); Assert.assertEquals("bigDecimalList",extractor.nameFor(getField("bigs"))); Assert.assertEquals("hashSet",extractor.nameFor(getField("bigsOld"))); Assert.assertEquals("class",extractor.nameFor(getField("clazz"))); Assert.assertEquals("aClassList",extractor.nameFor(AClass[].class)); Assert.assertEquals("urlClassLoaderList",extractor.nameFor(getField("urls"))); } | @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } |
@Test public void shouldDecapitalizeSomeCharsUntilItFindsOneUppercasedForListsAndArraysForBoundedGenericElements() throws NoSuchMethodException, SecurityException, NoSuchFieldException { Assert.assertEquals("bigDecimalList",extractor.nameFor(getField("bigsLimited"))); Assert.assertEquals("bigDecimalList",extractor.nameFor(getField("bigsLimited2"))); Assert.assertEquals("objectList",extractor.nameFor(getField("objects"))); } | @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } |
@Test public void shouldEncodeUriParameters() throws Exception { Method method = Controller.class.getDeclaredMethod("lang", String.class); when(encodingHandler.getEncoding()).thenReturn("UTF-8"); String uri = getDefaultParameterControlForUrl("/language/{lang}/about") .fillUri(nameProvider.parametersFor(method), "c#"); assertThat(uri, is(equalTo("/language/c%23/about"))); } | @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } | DefaultParametersControl implements ParametersControl { @Override public String fillUri(Parameter[] paramNames, Object... paramValues) { if (paramNames.length != paramValues.length) { String message = String.format("paramNames must have the same length as paramValues. Names: %s Values: %s", Arrays.toString(paramNames), Arrays.toString(paramValues)); throw new IllegalArgumentException(message); } String[] splittedPatterns = StringUtils.extractParameters(originalPattern); String base = originalPattern; for (int i=0; i<parameters.size(); i++) { String key = parameters.get(i); Object param = selectParam(key, paramNames, paramValues); Object result = evaluator.get(param, key); if (result != null) { Class<?> type = result.getClass(); if (converters.existsTwoWayFor(type)) { TwoWayConverter converter = converters.twoWayConverterFor(type); result = converter.convert(result); } } String parameter = encodeParameter(result == null ? "" : result.toString()); base = base.replace("{" + splittedPatterns[i] + "}", result == null ? "" : parameter); } return base.replaceAll("\\.\\*", ""); } DefaultParametersControl(String originalPattern, Map<String, String> parameterPatterns, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); DefaultParametersControl(String originalPattern, Converters converters, Evaluator evaluator, EncodingHandler encodingHandler); @Override String fillUri(Parameter[] paramNames, Object... paramValues); @Override boolean matches(String uri); @Override void fillIntoRequest(String uri, MutableRequest request); @Override String apply(String[] values); } |
@Test public void shouldDiscoverGenericTypeParametersWhenThereIsInheritance() throws Exception { Assert.assertEquals("t",extractor.nameFor(XController.class.getMethod("edit").getGenericReturnType())); Assert.assertEquals("tList",extractor.nameFor(XController.class.getMethod("list").getGenericReturnType())); } | @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } | DefaultTypeNameExtractor implements TypeNameExtractor { @Override public String nameFor(Type generic) { if (generic instanceof ParameterizedType) { return nameFor((ParameterizedType) generic); } if (generic instanceof WildcardType) { return nameFor((WildcardType) generic); } if (generic instanceof TypeVariable<?>) { return nameFor((TypeVariable<?>) generic); } return nameFor((Class<?>) generic); } @Override String nameFor(Type generic); } |
@Test public void shouldVerifyIfAcceptsMethodReturnsVoid() { exception.expect(InterceptionException.class); exception.expectMessage("@Accepts method must return boolean"); Class<VoidAcceptsInterceptor> type = VoidAcceptsInterceptor.class; List<Method> allMethods = stepInvoker.findAllMethods(type); validationRule.validate(type, allMethods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } protected AcceptsNeedReturnBooleanValidationRule(); @Inject AcceptsNeedReturnBooleanValidationRule(StepInvoker invoker); } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } protected AcceptsNeedReturnBooleanValidationRule(); @Inject AcceptsNeedReturnBooleanValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } protected AcceptsNeedReturnBooleanValidationRule(); @Inject AcceptsNeedReturnBooleanValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shouldVerifyIfAcceptsMethodReturnsNonBooleanType() { exception.expect(InterceptionException.class); exception.expectMessage("@Accepts method must return boolean"); Class<NonBooleanAcceptsInterceptor> type = NonBooleanAcceptsInterceptor.class; List<Method> allMethods = stepInvoker.findAllMethods(type); validationRule.validate(type, allMethods); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } protected AcceptsNeedReturnBooleanValidationRule(); @Inject AcceptsNeedReturnBooleanValidationRule(StepInvoker invoker); } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } protected AcceptsNeedReturnBooleanValidationRule(); @Inject AcceptsNeedReturnBooleanValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | AcceptsNeedReturnBooleanValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method accepts = invoker.findMethod(methods, Accepts.class, originalType); if (accepts != null && !isBooleanReturn(accepts.getReturnType())) { throw new InterceptionException(format("@%s method must return boolean", Accepts.class.getSimpleName())); } } protected AcceptsNeedReturnBooleanValidationRule(); @Inject AcceptsNeedReturnBooleanValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shouldNotReadInheritedMethods() throws Exception { Class<?> interceptorClass = InterceptorWithInheritance.class; Method method = findMethod(interceptorClass, BeforeCall.class); assertEquals(method, interceptorClass.getDeclaredMethod("begin")); } | public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } |
@Test public void shouldThrowsExceptionWhenInterceptorHasMoreThanOneAnnotatedMethod() { exception.expect(IllegalStateException.class); exception.expectMessage(InterceptorWithMoreThanOneBeforeCallMethod.class.getName() + " - You should not have more than one @BeforeCall annotated method"); Class<?> interceptorClass = InterceptorWithMoreThanOneBeforeCallMethod.class; findMethod(interceptorClass, BeforeCall.class); } | public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } |
@Test public void shouldFindFirstMethodAnnotatedWithInterceptorStep(){ ExampleOfSimpleStackInterceptor proxy = spy(new ExampleOfSimpleStackInterceptor()); findMethod(proxy.getClass(), BeforeCall.class); } | public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } |
@Test public void shouldFindMethodFromWeldStyleInterceptor() throws SecurityException, NoSuchMethodException{ Class<?> interceptorClass = WeldProxy$$$StyleInterceptor.class; assertNotNull(findMethod(interceptorClass, AroundCall.class)); } | public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } | StepInvoker { public Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass) { FluentIterable<Method> possibleMethods = FluentIterable.from(interceptorMethods).filter(hasStepAnnotation(step)); if (possibleMethods.size() > 1 && possibleMethods.allMatch(not(notSameClass(interceptorClass)))) { throw new IllegalStateException(String.format("%s - You should not have more than one @%s annotated method", interceptorClass.getCanonicalName(), step.getSimpleName())); } return possibleMethods.first().orNull(); } protected StepInvoker(); @Inject StepInvoker(ReflectionProvider reflectionProvider); Object tryToInvoke(Object interceptor, Method stepMethod, Object... params); List<Method> findAllMethods(Class<?> interceptorClass); Method findMethod(List<Method> interceptorMethods, Class<? extends Annotation> step, Class<?> interceptorClass); } |
@Test public void mustReceiveStackAsParameterForAroundCall() { exception.expect(IllegalStateException.class); exception.expectMessage("@AroundCall method must receive br.com.caelum.vraptor.core.InterceptorStack or br.com.caelum.vraptor.interceptor.SimpleInterceptorStack"); Class<?> type = AroundInterceptorWithoutSimpleStackParameter.class; validationRule.validate(type, invoker.findAllMethods(type)); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void mustNotReceiveStackAsParameterForAcceptsCall() { exception.expect(IllegalStateException.class); exception.expectMessage("Non @AroundCall method must not receive br.com.caelum.vraptor.core.InterceptorStack or br.com.caelum.vraptor.interceptor.SimpleInterceptorStack"); Class<?> type = AcceptsInterceptorWithStackAsParameter.class; validationRule.validate(type, invoker.findAllMethods(type)); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void mustNotReceiveStackAsParameterForBeforeAfterCall() { exception.expect(IllegalStateException.class); exception.expectMessage("Non @AroundCall method must not receive br.com.caelum.vraptor.core.InterceptorStack or br.com.caelum.vraptor.interceptor.SimpleInterceptorStack"); Class<?> type = BeforeAfterInterceptorWithStackAsParameter.class; validationRule.validate(type, invoker.findAllMethods(type)); } | @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } | NoStackParamValidationRule implements ValidationRule { @Override public void validate(Class<?> originalType, List<Method> methods) { Method aroundCall = invoker.findMethod(methods, AroundCall.class, originalType); Method afterCall = invoker.findMethod(methods, AfterCall.class, originalType); Method beforeCall = invoker.findMethod(methods, BeforeCall.class, originalType); Method accepts = invoker.findMethod(methods, Accepts.class, originalType); String interceptorStack = InterceptorStack.class.getName(); String simpleInterceptorStack = SimpleInterceptorStack.class.getName(); checkState(aroundCall == null || containsStack(aroundCall), "@AroundCall method must receive %s or %s", interceptorStack, simpleInterceptorStack); checkState(!containsStack(beforeCall) && !containsStack(afterCall) && !containsStack(accepts), "Non @AroundCall method must not receive %s or %s", interceptorStack, simpleInterceptorStack); } protected NoStackParamValidationRule(); @Inject NoStackParamValidationRule(StepInvoker invoker); @Override void validate(Class<?> originalType, List<Method> methods); } |
@Test public void shouldGetTypesCorrectly() throws Exception { final Method method = new Mirror().on(AController.class).reflect().method("aMethod").withArgs(Bean.class, String.class); DefaultTypeFinder finder = new DefaultTypeFinder(provider, new DefaultReflectionProvider()); Map<String, Class<?>> types = finder.getParameterTypes(method, new String[] {"bean.bean2.id", "path"}); assertEquals(Integer.class, types.get("bean.bean2.id")); assertEquals(String.class, types.get("path")); } | @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } | DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } } | DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } protected DefaultTypeFinder(); @Inject DefaultTypeFinder(ParameterNameProvider provider, ReflectionProvider reflectionProvider); } | DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } protected DefaultTypeFinder(); @Inject DefaultTypeFinder(ParameterNameProvider provider, ReflectionProvider reflectionProvider); @Override Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths); } | DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } protected DefaultTypeFinder(); @Inject DefaultTypeFinder(ParameterNameProvider provider, ReflectionProvider reflectionProvider); @Override Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths); } |
@Test public void shouldUnwrapCDIProxyFromControllerType() { ControllerInstance controllerInstance = controllerInstance(); assertTrue(CDIProxies.isCDIProxy(controller.getClass())); BeanClass beanClass = controllerInstance.getBeanClass(); assertFalse(CDIProxies.isCDIProxy(beanClass.getType())); } | @Override public BeanClass getBeanClass(){ Class<?> controllerClass = extractRawTypeIfPossible(controller.getClass()); return new DefaultBeanClass(controllerClass); } | DefaultControllerInstance implements ControllerInstance { @Override public BeanClass getBeanClass(){ Class<?> controllerClass = extractRawTypeIfPossible(controller.getClass()); return new DefaultBeanClass(controllerClass); } } | DefaultControllerInstance implements ControllerInstance { @Override public BeanClass getBeanClass(){ Class<?> controllerClass = extractRawTypeIfPossible(controller.getClass()); return new DefaultBeanClass(controllerClass); } DefaultControllerInstance(Object instance); } | DefaultControllerInstance implements ControllerInstance { @Override public BeanClass getBeanClass(){ Class<?> controllerClass = extractRawTypeIfPossible(controller.getClass()); return new DefaultBeanClass(controllerClass); } DefaultControllerInstance(Object instance); @Override Object getController(); @Override BeanClass getBeanClass(); } | DefaultControllerInstance implements ControllerInstance { @Override public BeanClass getBeanClass(){ Class<?> controllerClass = extractRawTypeIfPossible(controller.getClass()); return new DefaultBeanClass(controllerClass); } DefaultControllerInstance(Object instance); @Override Object getController(); @Override BeanClass getBeanClass(); } |
@Test public void shouldAddAllowHeader() throws Exception { this.handler.deny(request, response, EnumSet.of(HttpMethod.GET, HttpMethod.POST)); verify(response).addHeader("Allow", "GET, POST"); } | @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } |
@Test public void shouldSendErrorMethodNotAllowed() throws Exception { this.handler.deny(request, response, EnumSet.of(HttpMethod.GET, HttpMethod.POST)); verify(response).sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } | @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } |
@Test public void shouldNotSendMethodNotAllowedIfTheRequestMethodIsOptions() throws Exception { when(request.getMethod()).thenReturn("OPTIONS"); this.handler.deny(request, response, EnumSet.of(HttpMethod.GET, HttpMethod.POST)); verify(response, never()).sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } | @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } |
@Test public void shouldThrowInterceptionExceptionIfAnIOExceptionOccurs() throws Exception { exception.expect(InterceptionException.class); doThrow(new IOException()).when(response).sendError(anyInt()); this.handler.deny(request, response, EnumSet.of(HttpMethod.GET, HttpMethod.POST)); } | @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } | DefaultMethodNotAllowedHandler implements MethodNotAllowedHandler { @Override public void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods) { response.addHeader("Allow", Joiner.on(", ").join(allowedMethods)); try { if (!"OPTIONS".equalsIgnoreCase(request.getMethod())) { response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } } catch (IOException e) { throw new InterceptionException(e); } } @Override void deny(MutableRequest request, MutableResponse response, Set<HttpMethod> allowedMethods); } |
@Test public void shouldThrowExceptionWhenMethodIsAmbiguous() throws Throwable { try { invoke(handler.get(new DefaultBeanClass(TestController.class)), "method"); fail(); } catch (IllegalArgumentException e) { assertThat(e.getMessage().toLowerCase(), startsWith("ambiguous method")); } } | @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); } |
@Test public void shouldThrowExceptionWhenUsingParametersOfWrongTypes() throws Throwable { try { invoke(handler.get(new DefaultBeanClass(TestController.class)), "method", 123); fail(); } catch (IllegalArgumentException e) { assertThat(e.getMessage().toLowerCase(), startsWith("there are no methods")); } } | @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); } |
@Test public void shouldReturnWantedUrlWithoutArgs() throws Throwable { when(router.urlFor(TestController.class, anotherMethod, new Object[2])).thenReturn("/expectedURL"); String uri = invoke(handler.get(new DefaultBeanClass(TestController.class)), "anotherMethod"); assertThat(uri, is("/path/expectedURL")); } | @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); } | LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.