/** * Uses {@link org.mule.runtime.api.transformation.TransformationService} to get representation of a message for a given * {@link Class} * * @param message message to get payload from * @param clazz type of the payload to be transformed to * @return representation of the message payload of the required class * @throws Exception if there is an unexpected error obtaining the payload representation */ protected <T> T getPayload(Message message, Class<T> clazz) throws Exception { return (T) getPayload(message, DataType.fromType(clazz)); }
private List<TypedValue<?>> createListOfIntegers() { List<TypedValue<?>> integers = new ArrayList<>(3); for (int i = 0; i < 3; i++) { integers.add(new TypedValue<>(i, fromType(Integer.class))); } return integers; }
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; }
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 } }
@OnBackPressure public void onBackPressure(BackPressureContext ctx, NotificationEmitter notificationEmitter) { notificationEmitter.fireLazy(BATCH_FAILED, () -> ctx.getSourceCallbackContext().getVariable(BATCH_NUMBER).get(), fromType(Integer.class)); heisenberg.onBackPressure(ctx); }
@Override public List<FunctionParameter> parameters() { List<FunctionParameter> parameters = new ArrayList<>(); parameters.add(new FunctionParameter("word", STRING)); parameters.add(new FunctionParameter("times", fromType(Integer.class), ctx -> 1)); return parameters; }
@Test public void proxy() { final Class<?> muleMessageProxy = Proxy.getProxyClass(DataTypeBuilderTestCase.class.getClassLoader(), Message.class); final DataType dataType = DataType.fromType(muleMessageProxy); assertThat(dataType.getType(), is(equalTo(Message.class))); }
public NonSerializableToByteArray() { super(); registerSourceType(DataType.fromType(NonSerializable.class)); setReturnDataType(DataType.BYTE_ARRAY); }
@Test public void getListOfMapsFromJsonCar() throws MuleException { AttributeEvaluator attributeEvaluator = getAttributeEvaluator("#[[payload as Object]]", DataType.fromType(List.class)); List<Map<String, String>> cars = attributeEvaluator.resolveValue(newEvent(JSON_CAR, APPLICATION_JSON)); Map<String, String> car = cars.get(0); assertThat(car, hasEntry(is("price"), is(1000))); assertThat(car, hasEntry(is("color"), is("RED"))); }
@Test public void buildSimple() { final DataType dataType = DataType.fromType(String.class); assertThat(dataType, instanceOf(SimpleDataType.class)); assertThat(dataType.getType(), is(equalTo(String.class))); }
@Test public void getMapFromJsonCar() throws MuleException { AttributeEvaluator attributeEvaluator = getAttributeEvaluator("#[payload]", DataType.fromType(Map.class)); Map<String, String> car = attributeEvaluator.resolveValue(newEvent(JSON_CAR, APPLICATION_JSON)); assertThat(car, hasEntry(is("price"), is(1000))); assertThat(car, hasEntry(is("color"), is("RED"))); }
@Test public void buildCollection() { final DataType dataType = DataType.fromType(Set.class); assertThat(dataType, instanceOf(DefaultCollectionDataType.class)); assertThat(dataType.getType(), is(equalTo(Set.class))); assertThat(((DefaultCollectionDataType) dataType).getItemDataType(), is(OBJECT)); }
@Test public void getJavaPojo() throws MuleException { AttributeEvaluator attributeEvaluator = getAttributeEvaluator(DW_CAR, DataType.fromType(Car.class)); Object car = attributeEvaluator.resolveValue(newEvent()); assertThat(car, is(allOf(hasProperty("color", is("RED")), hasProperty("price", is(1000))))); }
@Test public void buildMap() { final DataType dataType = DataType.fromType(HashMap.class); assertThat(dataType, instanceOf(DefaultMapDataType.class)); assertThat(dataType.getType(), is(equalTo(HashMap.class))); assertThat(((DefaultMapDataType) dataType).getKeyDataType(), is(OBJECT)); assertThat(((DefaultMapDataType) dataType).getValueDataType(), is(OBJECT)); }
@Test public void accessRegistryCglibAnnotatedBean() throws Exception { CoreEvent event = testEvent(); MyBean annotatedMyBean = (MyBean) addAnnotationsToClass(MyBean.class).newInstance(); annotatedMyBean.setName("DataWeave"); when(registry.lookupByName("myBean")).thenReturn(of(annotatedMyBean)); TypedValue evaluate = expressionLanguage.evaluate("app.registry.myBean", fromType(MyBean.class), event, fromSingleComponent("flow"), BindingContext.builder().build(), false); assertThat(evaluate.getValue(), is(instanceOf(MyBean.class))); }
@Test public void accessRegistryAnnotatedBean() throws MuleException { CoreEvent event = testEvent(); when(registry.lookupByName("myBean")).thenReturn(of(new MyAnnotatedBean("DataWeave"))); TypedValue evaluate = expressionLanguage.evaluate("app.registry.myBean", fromType(MyBean.class), event, fromSingleComponent("flow"), BindingContext.builder().build(), false); assertThat(evaluate.getValue(), is(instanceOf(MyAnnotatedBean.class))); }
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 testExactMatch() throws Exception { Transformer trans = new MockConverterBuilder().from(DataType.fromType(IOException.class)).to(DataType.BYTE_ARRAY).build(); TransformerWeighting weighting = new TransformerWeighting(IOException.class, byte[].class, trans); assertFalse(weighting.isNotMatch()); assertTrue(weighting.isExactMatch()); }
@Test public void testNoMatchWeighting() throws Exception { Transformer trans = new MockConverterBuilder().from(DataType.fromType(Serializable.class)).to(DataType.BYTE_ARRAY).build(); TransformerWeighting weighting = new TransformerWeighting(FruitBowl.class, byte[].class, trans); assertTrue(weighting.isNotMatch()); assertEquals(-1, weighting.getInputWeighting()); assertEquals(0, weighting.getOutputWeighting()); }