private void verifyTransformerExecuted(Transformer converter1) throws TransformerException { verify(converter1, times(1)).transform(any(Object.class)); } }
private void verifyTransformerNotExecuted(Transformer converter1) throws TransformerException { verify(converter1, times(0)).transform(any(Object.class)); }
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 testTransform() throws Exception { Transformer trans = this.getTransformer(); Object result = trans.transform(getTestData()); Object expectedResult = this.getResultData(); final boolean match = this.compareResults(expectedResult, result); if (!match) { fail(format("Transformation result does not match expected result. Expected '%s', but got '%s'", expectedResult, result)); } }
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)); } }
@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(); } }
@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); }
@Test public void testRoundtripTransform() throws Exception { Transformer roundTripTransformer = this.getRoundTripTransformer(); // If null this is just a one way test if (roundTripTransformer != null) { Object result = roundTripTransformer.transform(this.getResultData()); assertNotNull("The result of the roundtrip transform shouldn't be null", result); final boolean match = this.compareRoundtripResults(this.getTestData(), result); if (!match) { fail(format("The result of the roundtrip transform does not match expected result. Expected '%s', but got '%s'", this.getTestData(), result)); } } }
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; }
@Test public void updatesMimeTypeOnTransformation() throws Exception { Message message = Message.builder().value(TEST_PAYLOAD).mediaType(ANY.withCharset(CUSTOM_ENCODING)).build(); Transformer transformer = mock(Transformer.class); when(transformer.isSourceDataTypeSupported(any())).thenReturn(true); DataType outputDataType = DataType.builder().type(Integer.class).mediaType(APPLICATION_XML).build(); when(transformer.getReturnDataType()).thenReturn(outputDataType); when(transformer.transform(any(Message.class))).thenReturn(1); CoreEvent muleEvent = mock(CoreEvent.class); Message result = transformationService.applyTransformers(message, muleEvent, singletonList(transformer)); assertDataType(result, Integer.class, APPLICATION_XML, CUSTOM_ENCODING); }
@Test public void updatesEncodingOnTransformation() throws Exception { Message message = Message.builder().value(TEST_PAYLOAD).mediaType(APPLICATION_XML_DEFAULT).build(); Transformer transformer = mock(Transformer.class); when(transformer.isSourceDataTypeSupported(any())).thenReturn(true); DataType outputDataType = DataType.builder().type(Integer.class).charset(CUSTOM_ENCODING).build(); when(transformer.getReturnDataType()).thenReturn(outputDataType); when(transformer.transform(anyObject())).thenReturn(Integer.valueOf(1)); CoreEvent muleEvent = mock(CoreEvent.class); Message result = transformationService.applyTransformers(message, muleEvent, singletonList(transformer)); assertDataType(result, Integer.class, APPLICATION_XML, CUSTOM_ENCODING); }
@Test public void updatesTypeOnTransformation() throws Exception { Message message = Message.builder().value(1).mediaType(APPLICATION_XML_DEFAULT).build(); Transformer transformer = mock(Transformer.class); when(transformer.isSourceDataTypeSupported(any())).thenReturn(true); DataType outputDataType = DataType.builder().type(Integer.class).mediaType(ANY).charset(DEFAULT_ENCODING).build(); when(transformer.getReturnDataType()).thenReturn(outputDataType); when(transformer.transform(anyObject())).thenReturn(1); CoreEvent muleEvent = mock(CoreEvent.class); Message result = transformationService.applyTransformers(message, muleEvent, singletonList(transformer)); assertDataType(result, Integer.class, APPLICATION_XML, DEFAULT_ENCODING); }
@Test public void maintainsDataTypeOnGetPayloadTransformation() throws Exception { InputStream payload = mock(InputStream.class); Message message = Message.builder().value(payload).mediaType(APPLICATION_XML_CUSTOM).build(); MuleRegistry muleRegistry = mock(MuleRegistry.class); when(muleContext.getRegistry()).thenReturn(muleRegistry); Transformer transformer = mock(Transformer.class); when(transformer.transform(anyObject(), anyObject())).thenReturn(TEST_PAYLOAD); when(muleRegistry.lookupTransformer(any(), any())).thenReturn(transformer); assertThat(message.getPayload().getDataType().getMediaType().getPrimaryType(), equalTo(APPLICATION_XML.getPrimaryType())); assertThat(message.getPayload().getDataType().getMediaType().getSubType(), equalTo(APPLICATION_XML.getSubType())); assertThat(message.getPayload().getDataType().getMediaType().getCharset().get(), equalTo(CUSTOM_ENCODING)); }
@Test public void testCompressAndDecompress() throws Exception { Transformer compressorTransformer = getTransformer(); Transformer decompressorTransformer = getRoundTripTransformer(); // Compress the test data. Object compressedData = compressorTransformer.transform(getTestData()); // Decompress the test data. Object decompressedData = decompressorTransformer.transform(compressedData); assertTrue(String.format("Compress and decompress process failed. Expected '%s', but got '%s'", getTestData(), decompressedData), compareResults(getTestData(), decompressedData)); } }
@Test public void failsOnConverterWhenSourceAndReturnTypeDoesNotMatchAndThereIsNoImplicitConversion2() throws MuleException { // Converter(B->C), payload A: FAIL ByteArrayInputStream payload = new ByteArrayInputStream(TEST_PAYLOAD.getBytes()); DataType originalSourceType = DataType.fromType(payload.getClass()); Transformer converter1 = new MockConverterBuilder().from(originalSourceType).to(dataTypeC).build(); A transformedPayload = new A(); when(converter1.transform(any())).thenReturn(transformedPayload); Message message = of(payload); try { transformationService.applyTransformers(message, null, converter1); fail("Transformation is supposed to fail"); } catch (MessageTransformerException expected) { assertThat(expected.getErrorMessage().getPayload().getValue(), is(transformedPayload)); } }
@Test public void testPayloadWrappedInMuleMessage() throws TransformerException { Object wrappedPayload = of(this.getResultData()); assertEquals(this.getTestData(), this.getRoundTripTransformer().transform(wrappedPayload)); }
@Test public void securityContextSerialization() throws Exception { Transformer transformer = createSerializableToByteArrayTransformer(); transformer.setMuleContext(muleContext); CoreEvent event = CoreEvent.builder(testEvent()).securityContext(createTestAuthentication()).build(); Serializable serialized = (Serializable) createSerializableToByteArrayTransformer().transform(event); assertNotNull(serialized); ByteArrayToObject trans = new ByteArrayToObject(); trans.setMuleContext(muleContext); CoreEvent deserialized = (CoreEvent) trans.transform(serialized); assertThat(deserialized.getSecurityContext().getAuthentication().getPrincipal(), is(event.getSecurityContext().getAuthentication().getPrincipal())); assertThat(deserialized.getSecurityContext().getAuthentication().getProperties().get("key1"), is(event.getSecurityContext().getAuthentication().getProperties().get("key1"))); assertThat(deserialized.getSecurityContext().getAuthentication().getCredentials(), is(event.getSecurityContext().getAuthentication().getCredentials())); }
@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()); }
@Test public void testEventSerializationRestart() throws Exception { // Create and register artifacts CoreEvent event = createEventToSerialize(); // Serialize Serializable serialized = (Serializable) createSerializableToByteArrayTransformer().transform(event); assertNotNull(serialized); // Simulate mule cold restart muleContext.dispose(); muleContext = createMuleContext(); muleContext.start(); ByteArrayToObject trans = new ByteArrayToObject(); trans.setMuleContext(muleContext); // Recreate and register artifacts (this would happen if using any kind of static config e.g. XML) createAndRegisterTransformersEndpointBuilderService(); // Deserialize 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()); }
@Test public void testTransform() throws Exception { Transformer trans = this.getTransformer(); Object result = trans.transform(getTestData()); Object expectedResult = this.getResultData(); final boolean match = this.compareResults(expectedResult, result); if (!match) { fail(format("Transformation result does not match expected result. Expected '%s', but got '%s'", expectedResult, result)); } }