/** * Configures the common parameters of every transformer. * * @param transformerInstance the transformar instance * @param parameters the set of parameters configured in the component model according to the * {@link org.mule.runtime.dsl.api.component.ComponentBuildingDefinition} */ @Override public void configure(AbstractTransformer transformerInstance, Map<String, Object> parameters) { String returnClass = (String) parameters.get("returnClass"); String mimeType = (String) parameters.get("mimeType"); String name = (String) parameters.get("name"); String encoding = (String) parameters.get("encoding"); Boolean ignoreBadInput = parameters.get("ignoreBadInput") == null ? null : Boolean.valueOf((String) parameters.get("ignoreBadInput")); if (returnClass != null || mimeType != null) { DataTypeParamsBuilder builder = DataType.builder().type(getReturnType(returnClass)); if (isNotEmpty(mimeType)) { builder.mediaType(mimeType); } transformerInstance.setReturnDataType(builder.charset(encoding).build()); } if (ignoreBadInput != null) { transformerInstance.setIgnoreBadInput(ignoreBadInput); } transformerInstance.setName(name); }
@Test public void transformsValidSourceTypeWithNoCheckForEnforcement() throws TransformerException { AbstractTransformer transformer = createDummyTransformer(true); transformer.sourceTypes.add(DataType.STRING); transformer.setReturnDataType(DataType.STRING); when(muleContext.getConfiguration()).thenReturn(muleConfiguration); Object result = transformer.transform("TEST"); assertEquals("TRANSFORMED", result); }
/** * @return transformer name */ @Override public String getName() { if (name == null) { name = this.generateTransformerName(); } return name; }
private AbstractTransformer createDummyTransformer(boolean ignoreBadInput) { AbstractTransformer result = new AbstractTransformer() { @Override protected Object doTransform(Object src, Charset enc) throws TransformerException { return "TRANSFORMED"; } }; result.sourceTypes.add(DataType.BYTE_ARRAY); result.setMuleContext(muleContext); result.setIgnoreBadInput(ignoreBadInput); return result; } }
@Override public int hashCode() { return hash(getReturnDataType(), getSourceDataTypes().hashCode(), isIgnoreBadInput(), isAllowNullReturn(), isAcceptNull(), getName(), getProcessingType()); }
private Transformer getIncreaseByOneTransformer() throws Exception { AbstractTransformer transformer = new AbstractTransformer() { @Override protected Object doTransform(Object src, Charset encoding) throws TransformerException { return new Integer(((Integer) src).intValue() + 1); } }; DataType integerDataType = DataType.fromType(Integer.class); transformer.registerSourceType(integerDataType); transformer.setReturnDataType(DataType.builder(integerDataType).charset(getDefaultEncoding(muleContext)).build()); return transformer; }
@Test(expected = MessageTransformerException.class) public void testIgnoreBadInputBreaksWithTransformationOrderInvalidValidWhenEnforcedOn() throws Exception { AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer(); assertNotNull(invalidTransformer); invalidTransformer.setIgnoreBadInput(true); AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer(); assertNotNull(validTransformer); Message message = of(new Integer(0)); Transformer messageTransformer = new TransformerChain(invalidTransformer, validTransformer); transformationService.applyTransformers(message, eventBuilder(muleContext).message(of(0)).build(), messageTransformer); }
@Override public void setReturnDataType(DataType type) { if (!Number.class.isAssignableFrom(type.getType())) { throw new IllegalArgumentException("This transformer only supports Number return types."); } else { super.setReturnDataType(type); } }
@Override public final Object transform(Object src) throws TransformerException { return transform(src, resolveEncoding(src)); }
@Test public void rejectsBadInputUsingDefaultEnforcement() throws TransformerException { AbstractTransformer transformer = createDummyTransformer(true); try { transformer.transform("TEST"); fail("Transformation should fail because source type is not supported"); } catch (TransformerException expected) { } }
if (src instanceof Message) { Message message = (Message) src; if ((!isSourceDataTypeSupported(DataType.MULE_MESSAGE, true) && !(this instanceof AbstractMessageTransformer))) { payload = message.getPayload().getValue(); sourceType = message.getPayload().getDataType(); if (!isSourceDataTypeSupported(sourceType)) { I18nMessage msg = transformOnObjectUnsupportedTypeOfEndpoint(getName(), payload.getClass()); logger.debug(format("Applying transformer %s (%s)", getName(), getClass().getName())); logger.debug(format("Object before transform: %s", StringMessageUtils.toString(payload))); Object result = doTransform(payload, enc);
protected Charset resolveEncoding(Object src) { return getReturnDataType().getMediaType().getCharset().orElse(getEncoding(src)); }
@Override public String toString() { StringBuilder sb = new StringBuilder(80); sb.append(ClassUtils.getSimpleName(this.getClass())); sb.append("{this=").append(Integer.toHexString(System.identityHashCode(this))); sb.append(", name='").append(name).append('\''); sb.append(", ignoreBadInput=").append(ignoreBadInput); sb.append(", returnClass=").append(getReturnDataType()); sb.append(", sourceTypes=").append(sourceTypes); sb.append('}'); return sb.toString(); }
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(getClass().equals(obj.getClass()))) { return false; } AbstractTransformer that = (AbstractTransformer) obj; return getReturnDataType().equals(that.getReturnDataType()) && getSourceDataTypes().equals(that.getSourceDataTypes()) && Objects.equals(isIgnoreBadInput(), that.isIgnoreBadInput()) && Objects.equals(isAllowNullReturn(), that.isAllowNullReturn()) && Objects.equals(isAcceptNull(), that.isAcceptNull()) && Objects.equals(getName(), that.getName()) && Objects.equals(getProcessingType(), that.getProcessingType()); } }
private Transformer getIncreaseByOneTransformer() throws Exception { AbstractTransformer transformer = new AbstractTransformer() { @Override protected Object doTransform(Object src, Charset encoding) throws TransformerException { return new Integer(((Integer) src).intValue() + 1); } }; DataType integerDataType = DataType.fromType(Integer.class); transformer.registerSourceType(integerDataType); transformer.setReturnDataType(DataType.builder(integerDataType).charset(getDefaultEncoding(muleContext)).build()); return transformer; }
@Test public void testIgnoreBadInputBreaksChainWithTransformationOrderInvalidValid() throws Exception { AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer(); assertNotNull(invalidTransformer); invalidTransformer.setIgnoreBadInput(false); AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer(); assertNotNull(validTransformer); Message message = of(new Integer(0)); Transformer messageTransformer = new TransformerChain(invalidTransformer, validTransformer); try { transformationService.applyTransformers(message, eventBuilder(muleContext).message(of(0)).build(), messageTransformer); fail("Transformer chain is expected to fail because of invalid transformer within chain."); } catch (MuleException tfe) { // ignore } }
private AbstractTransformer createDummyTransformer(boolean ignoreBadInput) { AbstractTransformer result = new AbstractTransformer() { @Override protected Object doTransform(Object src, Charset enc) throws TransformerException { return "TRANSFORMED"; } }; result.sourceTypes.add(DataType.BYTE_ARRAY); result.setMuleContext(muleContext); result.setIgnoreBadInput(ignoreBadInput); return result; } }
@Override public void setReturnDataType(DataType type) { if (!Boolean.class.isAssignableFrom(type.getType())) { throw new IllegalArgumentException("This transformer only supports Boolean return types."); } else { super.setReturnDataType(type); } }
@Test public void rejectsBadInputIfEnforcementOn() throws TransformerException { AbstractTransformer transformer = createDummyTransformer(true); try { transformer.transform("TEST"); fail("Transformation should fail because source type is not supported"); } catch (TransformerException expected) { } }
@SuppressWarnings({"unchecked"}) private Class<? extends Number> getType() { return (Class<Number>) super.getReturnDataType().getType(); }