@Test public void maintainsCurrentDataTypeClassWhenTransformerOutputTypeIsObject() throws Exception { Message message = of(TEST_PAYLOAD); Transformer transformer = mock(Transformer.class); when(transformer.isSourceDataTypeSupported(any())).thenReturn(true); DataType outputDataType = DataType.builder().type(Object.class).mediaType(ANY).build(); when(transformer.getReturnDataType()).thenReturn(outputDataType); when(transformer.transform(message)).thenReturn(TEST_PAYLOAD); CoreEvent muleEvent = mock(CoreEvent.class); Message result = transformationService.applyTransformers(message, muleEvent, singletonList(transformer)); assertDataType(result, String.class, ANY, DEFAULT_ENCODING); }
public Transformer build() { Transformer transformer; if (name == null || name.isEmpty()) { transformer = mock(getClassToMock()); } else { transformer = mock(getClassToMock(), name); doReturn(name).when(transformer).getName(); } if (resultDataType != null) { doReturn(resultDataType).when(transformer).getReturnDataType(); } if (sourceDataTypes != null) { doReturn(Arrays.asList(sourceDataTypes)).when(transformer).getSourceDataTypes(); when(transformer.isSourceDataTypeSupported(argThat(new SupportsSourceDataType()))).thenReturn(true); } try { doReturn(value).when(transformer).transform(Mockito.any(Object.class)); } catch (TransformerException e) { // Not going to happen during mock setup } return transformer; }
public void doTestBadReturnType(Transformer tran, Object src) throws Exception { tran.setReturnDataType(DataType.fromType(InvalidSatsuma.class)); try { tran.transform(src); fail("Should throw exception for bad return type"); } catch (TransformerException e) { // expected } }
@Test public void transformerIsNeverCalledWithANullValue() throws MuleException { MuleContext muleContext = mock(MuleContext.class); MuleConfiguration muleConfiguration = mock(MuleConfiguration.class); when(muleContext.getConfiguration()).thenReturn(muleConfiguration); ExtendedTransformationService transformationService = new ExtendedTransformationService(muleContext); Transformer transformer1 = mock(Transformer.class); when(transformer1.transform(any(Object.class))).thenReturn(null); when(transformer1.isSourceDataTypeSupported(any(DataType.class))).thenReturn(true); when(transformer1.getReturnDataType()).thenReturn(DataType.OBJECT); Transformer transformer2 = mock(Transformer.class); when(transformer2.transform(any(Object.class))).thenReturn("foo"); when(transformer2.isSourceDataTypeSupported(any(DataType.class))).thenReturn(true); when(transformer2.getReturnDataType()).thenReturn(DataType.OBJECT); Message message = transformationService.applyTransformers(of(""), null, transformer1, transformer2); assertEquals("foo", message.getPayload().getValue()); verify(transformer1, never()).transform(null); verify(transformer1, never()).isAcceptNull(); verify(transformer2, never()).transform(null); verify(transformer2, never()).isAcceptNull(); } }
private void verifyTransformerExecuted(Transformer converter1) throws TransformerException { verify(converter1, times(1)).transform(any(Object.class)); } }
@Test public void serialization() throws Exception { Transformer transformer = createSerializableToByteArrayTransformer(); transformer.setMuleContext(muleContext); Serializable serialized = (Serializable) createSerializableToByteArrayTransformer().transform(testEvent()); assertNotNull(serialized); ByteArrayToObject trans = new ByteArrayToObject(); trans.setMuleContext(muleContext); PrivilegedEvent deserialized = (PrivilegedEvent) trans.transform(serialized); // Assert that deserialized event is not null assertNotNull(deserialized); // Assert that deserialized event has session with same id assertNotNull(deserialized.getSession()); }
@Override public void applyLifecycle(Object o) throws LifecycleException { if (o instanceof SpringRegistry) { ((SpringRegistry) o).doDispose(); } else if (o instanceof Transformer) { String name = ((Transformer) o).getName(); if (isNamedBean(name)) { super.applyLifecycle(o); } } else { super.applyLifecycle(o); } }
@Override protected void doRegisterTransformer(TransformerBootstrapProperty bootstrapProperty, Class<?> returnClass, Class<? extends Transformer> transformerClass) throws Exception { Transformer trans = ClassUtils.instantiateClass(transformerClass); if (!(trans instanceof DiscoverableTransformer)) { throw new RegistrationException(CoreMessages.transformerNotImplementDiscoverable(trans)); } if (returnClass != null) { DataTypeParamsBuilder builder = DataType.builder().type(returnClass); if (isNotEmpty(bootstrapProperty.getMimeType())) { builder = builder.mediaType(bootstrapProperty.getMimeType()); } trans.setReturnDataType(builder.build()); } if (bootstrapProperty.getName() != null) { trans.setName(bootstrapProperty.getName()); } else { // Prefixes the generated default name to ensure there is less chance of conflict if the user registers // the transformer with the same name trans.setName("_" + trans.getName()); } ((MuleContextWithRegistries) muleContext).getRegistry().registerTransformer(trans); }
private Message transformMessage(final Message message, final CoreEvent event, final Transformer transformer) throws MessageTransformerException, TransformerException { Object result; if (transformer instanceof MessageTransformer) { result = ((MessageTransformer) transformer).transform(message, event); } else { result = transformer.transform(message); } if (result instanceof Message) { return (Message) result; } else { // We need to use message from event if it's available in case the transformer mutated the message by creating // a new message instance. This issue goes away once transformers are cleaned up and always return event or // message. See MULE-9342 Message messagePostTransform = (event != null && event.getMessage() != null) ? event.getMessage() : message; return Message.builder(messagePostTransform).value(result) .mediaType(mergeMediaType(messagePostTransform, transformer.getReturnDataType())).build(); } }
private static <S, R> R attemptTransformation(DataType sourceDataType, S source, DataType resultDataType, MuleContext muleContext) { Transformer transformer; try { transformer = ((MuleContextWithRegistries) muleContext).getRegistry().lookupTransformer(sourceDataType, resultDataType); } catch (TransformerException e) { LOGGER.debug("Could not find a transformer from type {} to {}", sourceDataType.getType().getName(), resultDataType.getType().getName()); return null; } LOGGER.debug("Located transformer {} from type {} to type {}. Attempting transformation...", transformer.getName(), sourceDataType.getType().getName(), resultDataType.getType().getName()); try { return (R) transformer.transform(source); } catch (TransformerException e) { if (LOGGER.isDebugEnabled()) { LOGGER.debug( format("Transformer %s threw exception while trying to transform an object of type %s into a %s", transformer.getName(), sourceDataType.getType().getName(), resultDataType.getType().getName()), e); } return null; } }
DataType originalSourceType = DataType.fromType(srcCls); if (transformer.isSourceDataTypeSupported(originalSourceType)) { if (logger.isDebugEnabled()) { logger.debug("Using " + transformer + " to transform payload."); muleContext.getDataTypeConverterResolver().resolve(originalSourceType, transformer.getSourceDataTypes()); DataType returnDataType = lastTransformer.getReturnDataType(); checkResultDataType(message, returnDataType, result.getPayload().getValue());
@Override default ProcessingType getProcessingType() { if (getReturnDataType().isStreamType() || getSourceDataTypes().stream().anyMatch(dataType -> dataType.isStreamType())) { return IO_RW; } else { return CPU_INTENSIVE; } }
continue; if (result.isCompatibleWith(transformer.getReturnDataType()) && transformer.isSourceDataTypeSupported(source)) { results.add(transformer);
private Transformer createSerializableToByteArrayTransformer() { Transformer transformer = new SerializableToByteArray(); transformer.setMuleContext(muleContext); return transformer; }
@Override public DataType getReturnDataType() { return transformer.getReturnDataType(); }
@Override public void setReturnDataType(DataType type) { transformer.setReturnDataType(type); }
private void createAndRegisterTransformersEndpointBuilderService() throws Exception { Transformer trans1 = new TestEventTransformer(); trans1.setName("OptimusPrime"); ((MuleContextWithRegistry) muleContext).getRegistry().registerTransformer(trans1); Transformer trans2 = new TestEventTransformer(); trans2.setName("Bumblebee"); ((MuleContextWithRegistry) muleContext).getRegistry().registerTransformer(trans2); List<Transformer> transformers = new ArrayList<>(); transformers.add(trans1); transformers.add(trans2); }
@Override public boolean isSourceDataTypeSupported(DataType dataType) { return transformer.isSourceDataTypeSupported(dataType); }
@Override public List<DataType> getSourceDataTypes() { return transformer.getSourceDataTypes(); }
@Override public void initialise() throws InitialisationException { for (Transformer transformer : transformers) { transformer.initialise(); } }