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 shouldOutjectWithASimpleTypeName() throws NoSuchMethodException { Method method = MyComponent.class.getMethod("returnsAString"); when(controllerMethod.getMethod()).thenReturn(method); when(methodInfo.getResult()).thenReturn("myString"); when(extractor.nameFor(String.class)).thenReturn("string"); outjectResult.outject(new MethodExecuted(controllerMethod, methodInfo), result, methodInfo); verify(result).include("string", "myString"); } | public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } protected OutjectResult(); @Inject OutjectResult(TypeNameExtractor extractor); } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } protected OutjectResult(); @Inject OutjectResult(TypeNameExtractor extractor); void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo); } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } protected OutjectResult(); @Inject OutjectResult(TypeNameExtractor extractor); void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo); } |
@Test public void shouldOutjectACollectionAsAList() throws NoSuchMethodException { Method method = MyComponent.class.getMethod("returnsStrings"); when(controllerMethod.getMethod()).thenReturn(method); when(methodInfo.getResult()).thenReturn("myString"); when(extractor.nameFor(method.getGenericReturnType())).thenReturn("stringList"); outjectResult.outject(new MethodExecuted(controllerMethod, methodInfo), result, methodInfo); verify(result).include("stringList", "myString"); } | public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } protected OutjectResult(); @Inject OutjectResult(TypeNameExtractor extractor); } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } protected OutjectResult(); @Inject OutjectResult(TypeNameExtractor extractor); void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo); } | OutjectResult { public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } } protected OutjectResult(); @Inject OutjectResult(TypeNameExtractor extractor); void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo); } |
@Test public void shouldTranslatePatternArgs() throws Exception { Method method = Controller.class.getDeclaredMethod("store", Client.class); String uri = getDefaultParameterControlForUrl("/clients/{client.id}").fillUri(nameProvider.parametersFor(method), client(3L)); assertThat(uri, is(equalTo("/clients/3"))); } | @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 doesNothingIfResultWasAlreadyUsed() { when(result.used()).thenReturn(true); interceptor.forward(new RequestSucceded(request, response)); verify(result, never()).use(PageResult.class); } | public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); void forward(@Observes RequestSucceded event); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); void forward(@Observes RequestSucceded event); } |
@Test public void doesNothingIfResponseIsCommited() { when(response.isCommitted()).thenReturn(true); interceptor.forward(new RequestSucceded(request, response)); verify(result, never()).use(PageResult.class); } | public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); void forward(@Observes RequestSucceded event); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); void forward(@Observes RequestSucceded event); } |
@Test public void shouldForwardToViewWhenResultWasNotUsed() { when(result.used()).thenReturn(false); when(result.use(PageResult.class)).thenReturn(new MockedPage()); interceptor.forward(new RequestSucceded(request, response)); verify(result).use(PageResult.class); } | public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); void forward(@Observes RequestSucceded event); } | ForwardToDefaultView { public void forward(@Observes RequestSucceded event) { if (result.used() || event.getResponse().isCommitted()) { logger.debug("Request already dispatched and commited somewhere else, not forwarding."); return; } logger.debug("forwarding to the dafault page for this logic"); result.use(Results.page()).defaultView(); } protected ForwardToDefaultView(); @Inject ForwardToDefaultView(Result result); void forward(@Observes RequestSucceded event); } |
@Test public void shouldNotAcceptIfMethodHasNoParameters() { methodInfo.setControllerMethod(method); verifyNoMoreInteractions(parametersProvider, validator, request, flash); instantiator.instantiate(new InterceptorsReady(method)); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldUseTheProvidedParameters() throws Exception { Object[] values = new Object[] { "bazinga" }; methodInfo.setControllerMethod(otherMethod); when(parametersProvider.getParametersFor(otherMethod, errors)).thenReturn(values); instantiator.instantiate(new InterceptorsReady(otherMethod)); verify(validator).addAll(Collections.<Message> emptyList()); assertEquals("bazinga", methodInfo.getValuedParameters()[0].getValue()); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldConvertArrayParametersToIndexParameters() throws Exception { when(request.getParameterNames()).thenReturn(enumeration(asList("someParam[].id", "unrelatedParam"))); when(request.getParameterValues("someParam[].id")).thenReturn(new String[] {"one", "two", "three"}); when(parametersProvider.getParametersFor(otherMethod, errors)).thenReturn(new Object[1]); methodInfo.setControllerMethod(otherMethod); instantiator.instantiate(new InterceptorsReady(otherMethod)); verify(request).setParameter("someParam[0].id", "one"); verify(request).setParameter("someParam[1].id", "two"); verify(request).setParameter("someParam[2].id", "three"); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldThrowExceptionWhenThereIsAParameterContainingDotClass() throws Exception { exception.expect(IllegalArgumentException.class); methodInfo.setControllerMethod(otherMethod); when(request.getParameterNames()).thenReturn(enumeration(asList("someParam.class.id", "unrelatedParam"))); when(request.getParameterValues("someParam.class.id")).thenReturn(new String[] {"whatever"}); instantiator.instantiate(new InterceptorsReady(otherMethod)); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldUseAndDiscardFlashParameters() throws Exception { Object[] values = new Object[] { "bazinga" }; methodInfo.setControllerMethod(otherMethod); when(flash.consumeParameters(otherMethod)).thenReturn(values); instantiator.instantiate(new InterceptorsReady(otherMethod)); verify(validator).addAll(Collections.<Message>emptyList()); verify(parametersProvider, never()).getParametersFor(otherMethod, errors); assertEquals("bazinga", methodInfo.getValuedParameters()[0].getValue()); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldValidateParameters() throws Exception { methodInfo.setControllerMethod(otherMethod); when(parametersProvider.getParametersFor(otherMethod, errors)) .thenAnswer(addErrorsToListAndReturn(new Object[] { 0 }, "error1")); instantiator.instantiate(new InterceptorsReady(otherMethod)); verify(validator).addAll(errors); assertEquals(methodInfo.getValuedParameters()[0].getValue(), 0); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldAddHeaderInformationToRequestWhenHeaderParamAnnotationIsPresent() throws Exception { Object[] values = new Object[] { "bazinga" }; Method method = HeaderParamComponent.class.getDeclaredMethod("method", String.class); ControllerMethod controllerMethod = DefaultControllerMethod.instanceFor(HeaderParamComponent.class, method); methodInfo.setControllerMethod(controllerMethod); when(request.getHeader("X-MyApp-Password")).thenReturn("123"); when(parametersProvider.getParametersFor(controllerMethod, errors)).thenReturn(values); instantiator.instantiate(new InterceptorsReady(controllerMethod)); verify(request).setParameter("password", "123"); verify(validator).addAll(Collections.<Message> emptyList()); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldTranslatePatternArgsWithRegex() throws Exception { Method method = Controller.class.getDeclaredMethod("show", Long.class); String uri = getDefaultParameterControlForUrl("/clients/{id:[0-9]{1,}}").fillUri(nameProvider.parametersFor(method), 30L); assertThat(uri, is(equalTo("/clients/30"))); } | @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 shouldNotAddHeaderInformationToRequestIfHeaderParamValueIsNull() throws Exception { Method method = HeaderParamComponent.class.getDeclaredMethod("method", String.class); ControllerMethod controllerMethod = DefaultControllerMethod.instanceFor(HeaderParamComponent.class, method); methodInfo.setControllerMethod(controllerMethod); when(request.getHeader("X-MyApp-Password")).thenReturn(null); when(parametersProvider.getParametersFor(controllerMethod, errors)).thenReturn(new Object[] { "" }); instantiator.instantiate(new InterceptorsReady(controllerMethod)); verify(request, never()).setParameter(anyString(), anyString()); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void shouldNotAddHeaderInformationToRequestWhenHeaderParamAnnotationIsNotPresent() throws Exception { Object[] values = new Object[] { "bazinga" }; when(parametersProvider.getParametersFor(otherMethod, errors)).thenReturn(values); methodInfo.setControllerMethod(otherMethod); instantiator.instantiate(new InterceptorsReady(otherMethod)); verify(request, never()).setParameter(anyString(), anyString()); verify(validator).addAll(Collections.<Message>emptyList()); } | public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } | ParametersInstantiator { public void instantiate(@Observes InterceptorsReady event) { if (!hasInstantiatableParameters()) return; fixIndexedParameters(request); addHeaderParametersToAttribute(); Object[] values = getParametersForCurrentMethod(); validator.addAll(errors); logger.debug("Conversion errors: {}", errors); logger.debug("Parameter values for {} are {}", methodInfo.getControllerMethod(), values); ValuedParameter[] valuedParameters = methodInfo.getValuedParameters(); for (int i = 0; i < valuedParameters.length; i++) { Parameter parameter = valuedParameters[i].getParameter(); if (parameter.isAnnotationPresent(HeaderParam.class)) { HeaderParam headerParam = parameter.getAnnotation(HeaderParam.class); valuedParameters[i].setValue(request.getHeader(headerParam.value())); } else { ValuedParameter valuedParameter = valuedParameters[i]; if (valuedParameter.getValue() == null) { valuedParameter.setValue(values[i]); } } } } protected ParametersInstantiator(); @Inject ParametersInstantiator(ParametersProvider provider, MethodInfo methodInfo, Validator validator,
MutableRequest request, FlashScope flash); void instantiate(@Observes InterceptorsReady event); } |
@Test public void whenResultIsADownloadShouldUseIt() throws Exception { when(controllerMethod.getMethod()).thenReturn(getMethod("download")); Download download = mock(Download.class); when(methodInfo.getResult()).thenReturn(download); downloadObserver.download(new MethodExecuted(controllerMethod, methodInfo), result); verify(download).write(response); } | public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void whenResultIsAnInputStreamShouldCreateAInputStreamDownload() throws Exception { when(controllerMethod.getMethod()).thenReturn(getMethod("asByte")); byte[] bytes = "abc".getBytes(); when(methodInfo.getResult()).thenReturn(new ByteArrayInputStream(bytes)); downloadObserver.download(new MethodExecuted(controllerMethod, methodInfo), result); verify(outputStream).write(argThat(is(arrayStartingWith(bytes))), eq(0), eq(3)); } | public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void whenResultIsAnInputStreamShouldCreateAByteArrayDownload() throws Exception { when(controllerMethod.getMethod()).thenReturn(getMethod("asByte")); byte[] bytes = "abc".getBytes(); when(methodInfo.getResult()).thenReturn(bytes); downloadObserver.download(new MethodExecuted(controllerMethod, methodInfo), result); verify(outputStream).write(argThat(is(arrayStartingWith(bytes))), eq(0), eq(3)); } | public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void whenResultIsAFileShouldCreateAFileDownload() throws Exception { when(controllerMethod.getMethod()).thenReturn(getMethod("file")); File tmp = tmpdir.newFile(); Files.write(tmp.toPath(), "abc".getBytes()); when(methodInfo.getResult()).thenReturn(tmp); downloadObserver.download(new MethodExecuted(controllerMethod, methodInfo), result); verify(outputStream).write(argThat(is(arrayStartingWith("abc".getBytes()))), eq(0), eq(3)); tmp.delete(); } | public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void whenResultIsNullShouldDoNothing() throws Exception { when(controllerMethod.getMethod()).thenReturn(getMethod("download")); when(result.used()).thenReturn(true); downloadObserver.download(new MethodExecuted(controllerMethod, methodInfo), result); verifyZeroInteractions(response); } | public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void whenResultWasUsedShouldDoNothing() throws Exception { when(controllerMethod.getMethod()).thenReturn(getMethod("download")); when(methodInfo.getResult()).thenReturn(null); downloadObserver.download(new MethodExecuted(controllerMethod, methodInfo), result); verifyZeroInteractions(response); } | public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public void download(@Observes MethodExecuted event, Result result) throws IOException { Object methodResult = event.getMethodInfo().getResult(); Download download = resolveDownload(methodResult); if (download != null && !result.used()) { logger.debug("Sending a file to the client"); result.use(DownloadView.class).of(download); } } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void shouldNotAcceptStringReturn() throws Exception { assertNull("String is not a Download", downloadObserver.resolveDownload("")); } | public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void shouldAcceptFile() throws Exception { File file = tmpdir.newFile(); assertThat(downloadObserver.resolveDownload(file), instanceOf(FileDownload.class)); } | public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void shouldTranslatePatternArgsWithMultipleRegexes() throws Exception { Method method = Controller.class.getDeclaredMethod("mregex", String.class, String.class, String.class); String uri = getDefaultParameterControlForUrl("/test/{hash1:[a-z0-9]{16}}{id}{hash2:[a-z0-9]{16}}/") .fillUri(nameProvider.parametersFor(method), "0123456789abcdef", "1234", "fedcba9876543210"); assertThat(uri, is(equalTo("/test/0123456789abcdef1234fedcba9876543210/"))); } | @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 shouldAcceptInput() throws Exception { InputStream inputStream = mock(InputStream.class); assertThat(downloadObserver.resolveDownload(inputStream), instanceOf(InputStreamDownload.class)); } | public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void shouldAcceptDownload() throws Exception { Download download = mock(Download.class); assertEquals(downloadObserver.resolveDownload(download), download); } | public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void shouldAcceptByte() throws Exception { assertThat(downloadObserver.resolveDownload(new byte[]{}), instanceOf(ByteArrayDownload.class)); } | public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } | DownloadObserver { public Download resolveDownload(Object result) throws IOException { if (result instanceof InputStream) { return new InputStreamDownload((InputStream) result, null, null); } if (result instanceof byte[]) { return new ByteArrayDownload((byte[]) result, null, null); } if (result instanceof File) { return new FileDownload((File) result, null, null); } if (result instanceof Download) { return (Download) result; } return null; } void download(@Observes MethodExecuted event, Result result); Download resolveDownload(Object result); } |
@Test public void shouldFlushWholeStreamToHttpResponse() throws IOException { ByteArrayDownload fd = new ByteArrayDownload(bytes, "type", "x.txt"); fd.write(response); assertArrayEquals(bytes, outputStream.toByteArray()); } | @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void shouldUseHeadersToHttpResponse() throws IOException { ByteArrayDownload fd = new ByteArrayDownload(bytes, "type", "x.txt"); fd.write(response); verify(response, times(1)).setHeader("Content-type", "type"); assertArrayEquals(bytes, outputStream.toByteArray()); } | @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void testConstructWithDownloadBuilder() throws Exception { Download fd = DownloadBuilder.of(bytes).withFileName("file.txt") .withContentType("text/plain").downloadable().build(); fd.write(response); verify(response).setHeader("Content-Length", String.valueOf(bytes.length)); verify(response).setHeader("Content-disposition", "attachment; filename=file.txt"); } | @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | ByteArrayDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { download.write(response); } ByteArrayDownload(byte[] buff, String contentType, String fileName); ByteArrayDownload(byte[] buff, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void shouldFlushWholeStreamToHttpResponse() throws IOException { InputStreamDownload fd = new InputStreamDownload(inputStream, "type", "x.txt"); fd.write(response); assertArrayEquals(bytes, outputStream.toByteArray()); } | @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } |
@Test public void shouldUseHeadersToHttpResponse() throws IOException { InputStreamDownload fd = new InputStreamDownload(inputStream, "type", "x.txt"); fd.write(response); verify(response).setHeader("Content-type", "type"); assertArrayEquals(bytes, outputStream.toByteArray()); } | @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } |
@Test public void testConstructWithDownloadBuilder() throws Exception { Download fd = DownloadBuilder.of(inputStream).withFileName("file.txt") .withSize(bytes.length) .withContentType("text/plain").downloadable().build(); fd.write(response); verify(response).setHeader("Content-Length", String.valueOf(bytes.length)); verify(response).setHeader("Content-disposition", "attachment; filename=file.txt"); } | @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } |
@Test public void inputStreamNeedBeClosed() throws Exception { InputStream streamMocked = spy(inputStream); InputStreamDownload fd = new InputStreamDownload(streamMocked, "type", "x.txt"); fd.write(response); verify(streamMocked,times(1)).close(); } | @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } | InputStreamDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { writeDetails(response); OutputStream out = response.getOutputStream(); ByteStreams.copy(stream, out); stream.close(); } InputStreamDownload(InputStream input, String contentType, String fileName); InputStreamDownload(InputStream input, String contentType, String fileName, boolean doDownload, long size); @Override void write(HttpServletResponse response); } |
@Test public void shouldTranslatePatternArgNullAsEmpty() throws Exception { Method method = Controller.class.getDeclaredMethod("store", Client.class); String uri = getDefaultParameterControlForUrl("/clients/{client.id}") .fillUri(nameProvider.parametersFor(method), client(null)); assertThat(uri, is(equalTo("/clients/"))); } | @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 shouldFlushWholeFileToHttpResponse() throws IOException { FileDownload fd = new FileDownload(file, "type"); fd.write(response); assertArrayEquals(bytes, outputStream.toByteArray()); } | @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void shouldUseHeadersToHttpResponse() throws IOException { FileDownload fd = new FileDownload(file, "type", "x.txt", false); fd.write(response); verify(response, times(1)).setHeader("Content-type", "type"); verify(response, times(1)).setHeader("Content-disposition", "inline; filename=x.txt"); assertArrayEquals(bytes, outputStream.toByteArray()); } | @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void builderShouldUseNameArgument() throws Exception { Download fd = DownloadBuilder.of(file).withFileName("file.txt") .withContentType("text/plain").downloadable().build(); fd.write(response); verify(response).setHeader("Content-Length", String.valueOf(file.length())); verify(response).setHeader("Content-disposition", "attachment; filename=file.txt"); } | @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void builderShouldUseFileNameWhenNameNotPresent() throws Exception { Download fd = DownloadBuilder.of(file).withContentType("text/plain").build(); fd.write(response); verify(response).setHeader("Content-Length", String.valueOf(file.length())); verify(response).setHeader("Content-disposition", "inline; filename=" + file.getName()); } | @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } | FileDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { try (InputStream stream = new FileInputStream(file)) { Download download = new InputStreamDownload(stream, contentType, fileName, doDownload, file.length()); download.write(response); } } FileDownload(File file, String contentType, String fileName); FileDownload(File file, String contentType); FileDownload(File file, String contentType, String fileName, boolean doDownload); @Override void write(HttpServletResponse response); } |
@Test public void builderShouldThrowsExceptionIfFileDoesntExists() throws Exception { thrown.expect(NoSuchFileException.class); Download download = new ZipDownload("file.zip", Paths.get("/path/that/doesnt/exists/picture.jpg")); download.write(response); } | @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); @Override void write(HttpServletResponse response); } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); @Override void write(HttpServletResponse response); } |
@Test public void shouldUseHeadersToHttpResponse() throws IOException { Download fd = new ZipDownload("download.zip", inpuFile0, inpuFile1); fd.write(response); verify(response, times(1)).setHeader("Content-type", "application/zip"); verify(response, times(1)).setHeader("Content-disposition", "attachment; filename=download.zip"); } | @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); @Override void write(HttpServletResponse response); } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); @Override void write(HttpServletResponse response); } |
@Test public void testConstructWithDownloadBuilder() throws Exception { Download fd = DownloadBuilder.of(asList(inpuFile0, inpuFile1)) .withFileName("download.zip") .downloadable().build(); fd.write(response); verify(response).setHeader("Content-disposition", "attachment; filename=download.zip"); } | @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); @Override void write(HttpServletResponse response); } | ZipDownload implements Download { @Override public void write(HttpServletResponse response) throws IOException { response.setHeader("Content-disposition", "attachment; filename=" + filename); response.setHeader("Content-type", "application/zip"); CheckedOutputStream stream = new CheckedOutputStream(response.getOutputStream(), new CRC32()); try (ZipOutputStream zip = new ZipOutputStream(stream)) { for (Path file : files) { zip.putNextEntry(new ZipEntry(file.getFileName().toString())); copy(file, zip); zip.closeEntry(); } } } ZipDownload(String filename, Iterable<Path> files); ZipDownload(String filename, Path... files); @Override void write(HttpServletResponse response); } |
@Test public void shouldNotResolveUnexistentKeys() throws Exception { exception.expect(NoSuchElementException.class); nonExistent.get(); } | @Produces @Property public String get(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); Property property = annotated.getAnnotation(Property.class); String key = property.value(); if (isNullOrEmpty(key)) { key = ip.getMember().getName(); } String defaultValue = property.defaultValue(); if(!isNullOrEmpty(defaultValue)){ return environment.get(key, defaultValue); } return environment.get(key); } | EnvironmentPropertyProducer { @Produces @Property public String get(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); Property property = annotated.getAnnotation(Property.class); String key = property.value(); if (isNullOrEmpty(key)) { key = ip.getMember().getName(); } String defaultValue = property.defaultValue(); if(!isNullOrEmpty(defaultValue)){ return environment.get(key, defaultValue); } return environment.get(key); } } | EnvironmentPropertyProducer { @Produces @Property public String get(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); Property property = annotated.getAnnotation(Property.class); String key = property.value(); if (isNullOrEmpty(key)) { key = ip.getMember().getName(); } String defaultValue = property.defaultValue(); if(!isNullOrEmpty(defaultValue)){ return environment.get(key, defaultValue); } return environment.get(key); } protected EnvironmentPropertyProducer(); @Inject EnvironmentPropertyProducer(Environment environment); } | EnvironmentPropertyProducer { @Produces @Property public String get(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); Property property = annotated.getAnnotation(Property.class); String key = property.value(); if (isNullOrEmpty(key)) { key = ip.getMember().getName(); } String defaultValue = property.defaultValue(); if(!isNullOrEmpty(defaultValue)){ return environment.get(key, defaultValue); } return environment.get(key); } protected EnvironmentPropertyProducer(); @Inject EnvironmentPropertyProducer(Environment environment); @Produces @Property String get(InjectionPoint ip); } | EnvironmentPropertyProducer { @Produces @Property public String get(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); Property property = annotated.getAnnotation(Property.class); String key = property.value(); if (isNullOrEmpty(key)) { key = ip.getMember().getName(); } String defaultValue = property.defaultValue(); if(!isNullOrEmpty(defaultValue)){ return environment.get(key, defaultValue); } return environment.get(key); } protected EnvironmentPropertyProducer(); @Inject EnvironmentPropertyProducer(Environment environment); @Produces @Property String get(InjectionPoint ip); } |
@Test public void shouldUseEnvironmentBasedFileIfFoundUnderEnvironmentFolder() throws IOException { DefaultEnvironment env = buildEnvironment(EnvironmentType.DEVELOPMENT); URL resource = env.getResource("/rules.txt"); assertThat(resource, notNullValue()); assertThat(resource, is(getClass().getResource("/development/rules.txt"))); } | @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldUseRootBasedFileIfNotFoundUnderEnvironmentFolder() throws IOException { DefaultEnvironment env = buildEnvironment(EnvironmentType.PRODUCTION); URL resource = env.getResource("/rules.txt"); assertThat(resource, notNullValue()); assertThat(resource, is(getClass().getResource("/rules.txt"))); } | @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public URL getResource(String name) { URL resource = getClass().getResource("/" + getEnvironmentType().getName() + name); if (resource != null) { LOG.debug("Loading resource {} from environment {}", name, getEnvironmentType().getName()); return resource; } return getClass().getResource(name); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldUseConverterIfItExists() throws Exception { Method method = Controller.class.getDeclaredMethod("store", Client.class); when(converters.existsTwoWayFor(Client.class)).thenReturn(true); when(converters.twoWayConverterFor(Client.class)).thenReturn(converter); when(converter.convert(any(Client.class))).thenReturn("john"); String uri = getDefaultParameterControlForUrl("/clients/{client}") .fillUri(nameProvider.parametersFor(method), client(null)); assertThat(uri, is(equalTo("/clients/john"))); } | @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 shouldLoadConfigurationInDefaultFileEnvironment() throws IOException { when(context.getInitParameter(DefaultEnvironment.ENVIRONMENT_PROPERTY)).thenReturn("production"); DefaultEnvironment env = buildEnvironment(context); assertThat(env.get("env_name"), is("production")); assertThat(env.get("only_in_default_file"), is("only_in_default_file")); } | @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldUseFalseWhenFeatureIsNotPresent() throws IOException { DefaultEnvironment env = buildEnvironment(context); assertThat(env.supports("feature_that_doesnt_exists"), is(false)); } | @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldTrimValueWhenEvaluatingSupports() throws Exception { DefaultEnvironment env = buildEnvironment(context); assertThat(env.supports("untrimmed_boolean"), is(true)); } | @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public boolean supports(String feature) { if (has(feature)) { return Boolean.parseBoolean(get(feature).trim()); } return false; } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldThrowExceptionIfKeyDoesNotExist() throws Exception { exception.expect(NoSuchElementException.class); DefaultEnvironment env = buildEnvironment(context); env.get("key_that_doesnt_exist"); } | @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldGetValueWhenIsPresent() throws Exception { DefaultEnvironment env = buildEnvironment(context); String value = env.get("env_name", "fallback"); assertThat(value, is("development")); } | @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldGetDefaultValueWhenIsntPresent() throws Exception { DefaultEnvironment env = buildEnvironment(context); String value = env.get("inexistent", "fallback"); assertThat(value, is("fallback")); } | @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public String get(String key) { if (!has(key)) { throw new NoSuchElementException(String.format("Key %s not found in environment %s", key, getName())); } String systemProperty = System.getProperty(key); if (!isNullOrEmpty(systemProperty)) { return systemProperty; } else { return properties.getProperty(key); } } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldUseContextInitParameterWhenSystemPropertiesIsntPresent() { when(context.getInitParameter(DefaultEnvironment.ENVIRONMENT_PROPERTY)).thenReturn("acceptance"); DefaultEnvironment env = buildEnvironment(context); assertThat(env.getName(), is("acceptance")); } | @Override public String getName() { return getEnvironmentType().getName(); } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void shouldUseSystemPropertiesWhenSysenvIsntPresent() { System.getProperties().setProperty(DefaultEnvironment.ENVIRONMENT_PROPERTY, "acceptance"); DefaultEnvironment env = buildEnvironment(context); verify(context, never()).getInitParameter(DefaultEnvironment.ENVIRONMENT_PROPERTY); assertThat(env.getName(), is("acceptance")); System.getProperties().remove(DefaultEnvironment.ENVIRONMENT_PROPERTY); } | @Override public String getName() { return getEnvironmentType().getName(); } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); } | DefaultEnvironment implements Environment { @Override public String getName() { return getEnvironmentType().getName(); } protected DefaultEnvironment(); @Inject DefaultEnvironment(ServletContext context); DefaultEnvironment(EnvironmentType environmentType); @Override boolean supports(String feature); @Override boolean has(String key); @Override String get(String key); @Override String get(String key, String defaultValue); @Override void set(String key, String value); @Override Iterable<String> getKeys(); @Override boolean isProduction(); @Override boolean isDevelopment(); @Override boolean isTest(); @Override URL getResource(String name); @Override String getName(); static final String ENVIRONMENT_PROPERTY; static final String BASE_ENVIRONMENT_FILE; } |
@Test public void whenThereIsNoFormatGivenShouldForwardToDefaultPage() { when(formatResolver.getAcceptFormat()).thenReturn(null); Serializer serializer = representation.from(new Object()); assertThat(serializer, is(instanceOf(IgnoringSerializer.class))); verify(status).notAcceptable(); } | @Override public <T> Serializer from(T object) { return from(object, null); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldSend404IfNothingIsRendered() { when(formatResolver.getAcceptFormat()).thenReturn(null); Serializer serializer = representation.from(null); assertThat(serializer, is(instanceOf(IgnoringSerializer.class))); verify(status).notFound(); } | @Override public <T> Serializer from(T object) { return from(object, null); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldTranslatePatternArgInternalNullAsEmpty() throws Exception { Method method = Controller.class.getDeclaredMethod("store", Client.class); String uri = getDefaultParameterControlForUrl("/clients/{client.child.id}") .fillUri(nameProvider.parametersFor(method), client(null)); assertThat(uri, is(equalTo("/clients/"))); } | @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 shouldDeferToContainerIfStaticFile() throws Exception { HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); FilterChain chain = mock(FilterChain.class); handler.setRequestingStaticFile(true); vRaptor.doFilter(request, response, chain); assertThat(handler.isDeferProcessingToContainerCalled(), is(true)); } | @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 whenThereIsNoFormatGivenShouldForwardToDefaultPageWithAlias() { when(formatResolver.getAcceptFormat()).thenReturn(null); Object object = new Object(); Serializer serializer = representation.from(object, "Alias!"); assertThat(serializer, is(instanceOf(IgnoringSerializer.class))); verify(status).notAcceptable(); } | @Override public <T> Serializer from(T object) { return from(object, null); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void whenThereIsAFormatGivenShouldUseCorrectSerializer() { when(formatResolver.getAcceptFormat()).thenReturn("xml"); when(serialization.accepts("xml")).thenReturn(true); Object object = new Object(); representation.from(object); verify(serialization).from(object); } | @Override public <T> Serializer from(T object) { return from(object, null); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void whenThereIsAFormatGivenShouldUseCorrectSerializerWithAlias() { when(formatResolver.getAcceptFormat()).thenReturn("xml"); when(serialization.accepts("xml")).thenReturn(true); Object object = new Object(); representation.from(object, "Alias!"); verify(serialization).from(object, "Alias!"); } | @Override public <T> Serializer from(T object) { return from(object, null); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void whenSerializationDontAcceptsFormatItShouldntBeUsed() { when(formatResolver.getAcceptFormat()).thenReturn("xml"); when(serialization.accepts("xml")).thenReturn(false); Object object = new Object(); representation.from(object); verify(serialization, never()).from(object); } | @Override public <T> Serializer from(T object) { return from(object, null); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } | DefaultRepresentationResult implements RepresentationResult { @Override public <T> Serializer from(T object) { return from(object, null); } protected DefaultRepresentationResult(); @Inject DefaultRepresentationResult(FormatResolver formatResolver, Result result, @Any Instance<Serialization> serializations); @Override Serializer from(T object); @Override Serializer from(T object, String alias); } |
@Test public void shouldNotAcceptMethodsWithoutArguments() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("Methods that consumes xml must receive just one argument"); deserializer.deserialize(new ByteArrayInputStream(new byte[0]), woof); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldBeAbleToDeserializeADog() throws Exception { InputStream stream = new ByteArrayInputStream("<dog><name>Brutus</name><age>7</age></dog>".getBytes()); Object[] deserialized = deserializer.deserialize(stream, bark); assertThat(deserialized.length, is(1)); assertThat(deserialized[0], is(instanceOf(Dog.class))); Dog dog = (Dog) deserialized[0]; assertThat(dog.name, is("Brutus")); assertThat(dog.age, is(7)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldBeAbleToDeserializeADogAsISO8601() throws Exception { InputStream stream = new ByteArrayInputStream("<dog><name>Otto</name><age>2</age><birthday>2013-07-23T17:14:14-03:00</birthday></dog>" .getBytes()); Object[] deserialized = deserializer.deserialize(stream, bark); Calendar birthday = new GregorianCalendar(2013, 6, 23, 17, 14, 14); birthday.setTimeZone(TimeZone.getTimeZone("GMT-0300")); assertThat(deserialized.length, is(1)); assertThat(deserialized[0], is(instanceOf(Dog.class))); Dog dog = (Dog) deserialized[0]; assertThat(dog.name, is("Otto")); assertThat(dog.age, is(2)); assertThat(dog.birthday.compareTo(birthday), is(0)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldBeAbleToDeserializeADogWhenMethodHasMoreThanOneArgument() throws Exception { InputStream stream = new ByteArrayInputStream("<dog><name>Brutus</name><age>7</age></dog>".getBytes()); Object[] deserialized = deserializer.deserialize(stream, jump); assertThat(deserialized.length, is(2)); assertThat(deserialized[0], is(instanceOf(Dog.class))); Dog dog = (Dog) deserialized[0]; assertThat(dog.name, is("Brutus")); assertThat(dog.age, is(7)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldBeAbleToDeserializeADogWhenMethodHasMoreThanOneArgumentAndTheXmlIsTheLastOne() throws Exception { InputStream stream = new ByteArrayInputStream("<dog><name>Brutus</name><age>7</age></dog>".getBytes()); Object[] deserialized = deserializer.deserialize(stream, dropDead); assertThat(deserialized.length, is(2)); assertThat(deserialized[1], is(instanceOf(Dog.class))); Dog dog = (Dog) deserialized[1]; assertThat(dog.name, is("Brutus")); assertThat(dog.age, is(7)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldBeAbleToDeserializeADogNamedDifferently() throws Exception { InputStream stream = new ByteArrayInputStream("<dog><name>Brutus</name><age>7</age></dog>".getBytes()); Object[] deserialized = deserializer.deserialize(stream, bark); assertThat(deserialized.length, is(1)); assertThat(deserialized[0], is(instanceOf(Dog.class))); Dog dog = (Dog) deserialized[0]; assertThat(dog.name, is("Brutus")); assertThat(dog.age, is(7)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldMatchPatternLazily() throws Exception { DefaultParametersControl wrong = getDefaultParameterControlForUrl("/clients/{client.id}/"); DefaultParametersControl right = getDefaultParameterControlForUrl("/clients/{client.id}/subtask/"); String uri = "/clients/3/subtask/"; assertThat(wrong.matches(uri), is(false)); assertThat(right.matches(uri), is(true)); } | @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 shouldBeAbleToDeserializeADogWhenAliasConfiguredByAnnotations() { InputStream stream = new ByteArrayInputStream("<dogAnnotated><nameAnnotated>Lubi</nameAnnotated><ageAnnotated>8</ageAnnotated></dogAnnotated>".getBytes()); Object[] deserialized = deserializer.deserialize(stream, annotated); assertThat(deserialized.length, is(1)); assertThat(deserialized[0], is(instanceOf(DogWithAnnotations.class))); DogWithAnnotations dog = (DogWithAnnotations) deserialized[0]; assertThat(dog.name, is("Lubi")); assertThat(dog.age, is(8)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldBeAbleToDeserializeAPersonWithDog() throws Exception { InputStream stream = new ByteArrayInputStream("<person><name>Renan</name><dog><name>Brutus</name><age>7</age></dog></person>".getBytes()); Object[] deserialized = deserializer.deserialize(stream, walk); assertThat(deserialized.length, is(1)); assertThat(deserialized[0], is(instanceOf(Person.class))); Person person = (Person) deserialized[0]; assertThat(person.name, is("Renan")); assertThat(person.dog.name, is("Brutus")); assertThat(person.dog.age, is(7)); } | @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } | XStreamXMLDeserializer implements Deserializer { @Override public Object[] deserialize(InputStream inputStream, ControllerMethod method) { Method javaMethod = method.getMethod(); Class<?>[] types = javaMethod.getParameterTypes(); if (types.length == 0) { throw new IllegalArgumentException("Methods that consumes xml must receive just one argument: the xml root element"); } XStream xStream = getConfiguredXStream(javaMethod, types); Object[] params = new Object[types.length]; chooseParam(types, params, xStream.fromXML(inputStream)); return params; } protected XStreamXMLDeserializer(); @Inject XStreamXMLDeserializer(ParameterNameProvider provider, XStreamBuilder builder); @Override Object[] deserialize(InputStream inputStream, ControllerMethod method); XStream getConfiguredXStream(Method javaMethod, Class<?>[] types); } |
@Test public void shouldSerializeGenericClass() { String expectedResult = "<genericWrapper><entityList class=\"list\"><client><name>washington botelho</name></client><client><name>washington botelho</name></client></entityList><total>2</total></genericWrapper>"; 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) { 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 shouldSerializeCalendarAsISO8601() { String expectedResult = "<client><name>Otto</name><creation>2013-09-12T22:09:13-03:00</creation></client>"; Calendar calendar = Calendar.getInstance(); calendar.set(2013, 8, 12, 22, 9, 13); calendar.set(Calendar.MILLISECOND, 0); calendar.setTimeZone(TimeZone.getTimeZone("America/Sao_Paulo")); Client otto = new Client("Otto", null, calendar); serialization.from(otto).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 shouldSerializeMaps() { String expectedResult = "<properties><map><entry><string>test</string><string>true</string></entry></map></properties>"; serialization.from(new Properties("test", "true")).include("map").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 shouldSerializeAllBasicFields() { String expectedResult = "<order><price>15.0</price><comments>pack it nicely, please</comments></order>"; 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) { 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 shouldUseAlias() { String expectedResult = "<customOrder><price>15.0</price><comments>pack it nicely, please</comments></customOrder>"; 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) { 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 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</type>")); } | @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 shouldSerializeCollection() { String expectedResult = "<order><price>15.0</price><comments>pack it nicely, please</comments></order>"; expectedResult += expectedResult; expectedResult = "<list>" + expectedResult + "</list>"; 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) { 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 shouldSerializeCollectionWithPrefixTag() { String expectedResult = "<order><price>15.0</price><comments>pack it nicely, please</comments></order>"; expectedResult += expectedResult; expectedResult = "<orders>" + expectedResult + "</orders>"; 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) { 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 shouldMatchMoreThanOneVariable() throws Exception { DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{client.id}/subtask/{task.id}/"); assertThat(control.matches("/clients/3/subtask/5/"), is(true)); } | @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 shouldIncludeFieldsFromACollection() { 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").include("items").serialize(); assertThat(result(), containsString("<items>")); assertThat(result(), containsString("<name>name</name>")); assertThat(result(), containsString("<price>12.99</price>")); 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 shouldWorkWithEmptyCollections() { serialization.from(new ArrayList<Order>(), "orders").serialize(); assertThat(result(), containsString("<orders/>")); } | @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 shouldIncludeAllFieldsWhenRecursive() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).recursive().serialize(); assertThat(result(), containsString("<items>")); assertThat(result(), containsString("<name>name</name>")); assertThat(result(), containsString("<price>12.99</price>")); } | @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 shouldExcludeFieldsFromACollection() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please"); serialization.from(Arrays.asList(order, order), "orders").exclude("price").serialize(); assertThat(result(), not(containsString("<price>"))); } | @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 shouldThrowAnExceptionWhenYouIncludeANonExistantField() { exception.expect(IllegalArgumentException.class); exception.expectMessage("Field path 'wrongFieldName' doesn't exists in class"); Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("wrongFieldName").serialize(); } | @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 shouldThrowAnExceptionWhenYouIncludeANonExistantFieldInsideOther() { exception.expect(IllegalArgumentException.class); exception.expectMessage("Field path 'wrongFieldName.client' doesn't exists in class"); Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("wrongFieldName.client").serialize(); } | @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 shouldThrowAnExceptionWhenYouIncludeANonExistantFieldInsideOtherNonExistantField() { exception.expect(IllegalArgumentException.class); exception.expectMessage("Field path 'wrongFieldName.another' doesn't exists in class"); Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("wrongFieldName.another").serialize(); assertThat(result(), not(containsString("<order><price>15.0</price><comments>pack it nicely, please</comments></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 shouldIgnoreWhenIncludeANonExistantField() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("?wrongFieldName").serialize(); assertThat(result(), containsString("<order><price>15.0</price><comments>pack it nicely, please</comments></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 shouldIgnoreWhenYouIncludeAOptionalNonExistantFieldInsideOther() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("?wrongFieldName.another").serialize(); assertThat(result(), containsString("<order><price>15.0</price><comments>pack it nicely, please</comments></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 shouldIgnoreWhenYouIncludeANonExistantFieldInsideOther() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("?wrongFieldName.?another").serialize(); assertThat(result(), containsString("<order><price>15.0</price><comments>pack it nicely, please</comments></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 shouldBeGreedyWhenIPutAnAsteriskOnExpression() throws Exception { DefaultParametersControl control = getDefaultParameterControlForUrl("/clients/{pathToFile*}"); assertThat(control.matches("/clients/my/path/to/file/"), is(true)); } | @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 shouldIncludeWhenYouIncludeAOptionsExistantFieldInsideOther() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("?client").serialize(); assertThat(result(), containsString("<client>")); } | @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 shouldIgnoreWhenYouIncludeANonExistantFieldInsideOtherNonExistantField() { Order order = new Order(new Client("guilherme silveira"), 15.0, "pack it nicely, please", new Item("name", 12.99)); serialization.from(order).include("?wrongFieldName.?another").serialize(); assertThat(result(), containsString("<order><price>15.0</price><comments>pack it nicely, please</comments></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 shouldSerializeParentFields() { Order order = new AdvancedOrder(null, 15.0, "pack it nicely, please", "complex package"); serialization.from(order).serialize(); assertThat(result(), containsString("<notes>complex package</notes>")); } | @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 shouldOptionallyExcludeFields() { String expectedResult = "<order><comments>pack it nicely, please</comments></order>"; 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) { 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 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</name>")); assertThat(result(), not(containsString("R. Vergueiro"))); } | @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 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</street>")); } | @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 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("<name>guilherme silveira</name>"))); } | @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 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</name>")); assertThat(result(), containsString("<price>12.99</price>")); 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); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.