@Override protected Object doTransform(Object src, Charset encoding) throws TransformerException { throw new TransformerException(I18nMessageFactory.createStaticMessage("Failure")); } }
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 } }
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; } }
private void verifyTransformerExecuted(Transformer converter1) throws TransformerException { verify(converter1, times(1)).transform(any(Object.class)); } }
@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); }
@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); } }
@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); }
@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) { } }
private Transformer createSerializableToByteArrayTransformer() { Transformer transformer = new SerializableToByteArray(); transformer.setMuleContext(muleContext); return transformer; }
public NullResultTransformer() { super(); this.registerSourceType(DataType.OBJECT); this.setReturnDataType(DataType.fromObject(null)); }
@Test public void testNullNotExpected() throws Exception { transformer.setReturnDataType(DataType.STRING); try { testTransform(); fail("Transformer should have thrown an exception because the return class doesn't match the result."); } catch (TransformerException e) { // expected } }
@Override public Converter build() { Transformer converter = super.build(); doReturn(weight).when((Converter) converter).getPriorityWeighting(); return (Converter) converter; }
@Test public void setMuleContext() { MuleContext mockMuleContext = mock(MuleContext.class); CompositeConverter compositeConverter = new CompositeConverter(mockConverterA, mockConverterB); compositeConverter.setMuleContext(mockMuleContext); verify(mockConverterA, atLeastOnce()).setMuleContext(mockMuleContext); verify(mockConverterB, atLeastOnce()).setMuleContext(mockMuleContext); }
@Test public void initialise() throws Exception { CompositeConverter compositeConverter = new CompositeConverter(mockConverterA, mockConverterB); compositeConverter.initialise(); verify(mockConverterA, atLeastOnce()).initialise(); verify(mockConverterB, atLeastOnce()).initialise(); }
@Test public void setReturnDataType() { Converter converter = mock(Converter.class); CompositeConverter chain = new CompositeConverter(converter); chain.setReturnDataType(DataType.STRING); verify(converter, atLeastOnce()).setReturnDataType(DataType.STRING); }
private Transformer getInvalidTransformer() throws Exception { AbstractTransformer transformer = new AbstractTransformer() { @Override protected Object doTransform(final Object src, final Charset encoding) throws TransformerException { throw new RuntimeException("This transformer must not perform any transformations."); } }; // Use this class as a bogus source type to enforce a simple invalid transformer transformer.registerSourceType(DataType.fromType(this.getClass())); return transformer; }
private void verifyTransformerNotExecuted(Transformer converter1) throws TransformerException { verify(converter1, times(0)).transform(any(Object.class)); }
@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) { } }
protected void testType(String string, Class type, Class primitive, Object value) throws TransformerException { assertEquals(value, lookupFromStringTransformer(type).transform(string)); assertEquals(string, lookupToStringTransformer(type).transform(value)); if (primitive != null) { assertEquals(value, lookupFromStringTransformer(primitive).transform(string)); assertEquals(string, lookupToStringTransformer(primitive).transform(value)); } }