@Override public Object processMessage(Message<?> message) { Node node = this.converter.convertToNode(message.getPayload()); Object result = this.evaluationType.evaluateXPath(this.expression, node); if (result instanceof String && ((String) result).length() == 0) { result = null; } if (result != null && this.headerTypeDescriptor != null) { return this.typeConverter.convertValue(result, TypeDescriptor.forObject(result), this.headerTypeDescriptor); } else { return result; } }
@Test public void testObjectToStringIsConverted() { ConversionService conversionService = mock(ConversionService.class); when(conversionService.canConvert(any(TypeDescriptor.class), any(TypeDescriptor.class))) .thenReturn(true); when(conversionService.convert(any(), any(TypeDescriptor.class), any(TypeDescriptor.class))) .thenReturn("foo"); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); Object object = new Object(); assertEquals("foo", typeConverter.convertValue(object, TypeDescriptor.valueOf(Object.class), TypeDescriptor.valueOf(String.class))); }
@SuppressWarnings("unchecked") @Test public void testEmptyCollectionConversion() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); List<String> sourceObject = new ArrayList<>(); ArrayList<BeanFactoryTypeConverterTests> convertedCollection = (ArrayList<BeanFactoryTypeConverterTests>) typeConverter.convertValue(sourceObject, TypeDescriptor.forObject(sourceObject), TypeDescriptor.forObject(new ArrayList<BeanFactoryTypeConverterTests>())); assertEquals(sourceObject, convertedCollection); }
@Test public void testDelegateWithTargetUUID() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); UUID uuid = UUID.randomUUID(); Object converted = typeConverter.convertValue(uuid.toString(), TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(UUID.class)); assertEquals(uuid, converted); }
@Test public void testToNonStringConversionNotSupportedByGenericConversionService() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); @SuppressWarnings("unchecked") Collection<Integer> converted = (Collection<Integer>) typeConverter.convertValue(1234, TypeDescriptor.valueOf(Integer.class), TypeDescriptor.forObject(new ArrayList<>(Arrays.asList(1)))); assertEquals(Collections.singletonList(1234), converted); }
@Test public void testEditorWithTargetString() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); UUID uuid = UUID.randomUUID(); Object foo = typeConverter.convertValue(uuid, TypeDescriptor.valueOf(UUID.class), TypeDescriptor.valueOf(String.class)); assertEquals(uuid.toString(), foo); }
Runnable test = () -> { beanFactoryTypeConverter.canConvert(sourceType, targetType); beanFactoryTypeConverter.convertValue(UUID.randomUUID(), sourceType, targetType); }; exec.execute(test);
@Test public void testVoidArg() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); Object foo = typeConverter.convertValue(null, null, TypeDescriptor.valueOf(Void.class)); assertNull(foo); foo = typeConverter.convertValue(null, null, TypeDescriptor.valueOf(Void.TYPE)); assertNull(foo); }
@Test public void testToStringConversion() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); String converted = (String) typeConverter.convertValue(1234, TypeDescriptor.valueOf(Integer.class), TypeDescriptor.valueOf(String.class)); assertEquals("1234", converted); }
@Test public void testNullArg() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); Object foo = typeConverter.convertValue(null, null, TypeDescriptor.valueOf(Bar.class)); assertNull(foo); }
@Test public void testEditorWithTargetFoo() { DefaultConversionService conversionService = new DefaultConversionService(); final Foo foo = new Foo(); conversionService.addConverter(new Converter<String, Foo>() { // Must be explicit type with generics @Override public Foo convert(String source) { return foo; } }); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); UUID uuid = UUID.randomUUID(); Object convertedFoo = typeConverter.convertValue(uuid, TypeDescriptor.valueOf(UUID.class), TypeDescriptor.valueOf(Foo.class)); assertSame(foo, convertedFoo); }
@Test public void testByteArrayNotConverted() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); byte[] bytes = new byte[1]; assertSame(bytes, typeConverter.convertValue(bytes, TypeDescriptor.valueOf(byte[].class), TypeDescriptor.valueOf(byte[].class))); }
@Test public void testStringToObjectNotConverted() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); String string = "foo"; assertSame(string, typeConverter.convertValue(string, TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(Object.class))); }
return text; return convertValue(text, TypeDescriptor.valueOf(String.class), targetType);
foos.put("foo", fooMap); bars = (Map<String, Map<String, Set<Bar>>>) typeConverter.convertValue(foos, sourceType, targetType); assertThat(bars.get("foo").get("foo").iterator().next(), instanceOf(Bar.class));
@Test public void testMessageHeadersNotConverted() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); MessageHeaders headers = new GenericMessage<>("foo").getHeaders(); assertSame(headers, typeConverter.convertValue(headers, TypeDescriptor.valueOf(MessageHeaders.class), TypeDescriptor.valueOf(MessageHeaders.class))); }
@Test public void testMessageHistoryNotConverted() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); Message<String> message = new GenericMessage<>("foo"); message = MessageHistory.write(message, new NamedComponent() { @Override public String getComponentName() { return "bar"; } @Override public String getComponentType() { return "baz"; } }); MessageHistory history = MessageHistory.read(message); assertSame(history, typeConverter.convertValue(history, TypeDescriptor.valueOf(MessageHistory.class), TypeDescriptor.valueOf(MessageHistory.class))); }
return text; return convertValue(text, TypeDescriptor.valueOf(String.class), targetType);