@Test
  public void testSimpleDiscovery() throws Exception {
    Transformer t =
        muleContext
            .getRegistry()
            .lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(Apple.class));
    assertNotNull(t);
    assertEquals(StringToApple.class, t.getClass());

    t =
        muleContext
            .getRegistry()
            .lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(Orange.class));
    assertNotNull(t);
    assertEquals(StringToOrange.class, t.getClass());

    try {
      muleContext
          .getRegistry()
          .lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(Banana.class));
      fail("There is no transformer to go from String to Banana");
    } catch (TransformerException e) {
      // expected
    }

    muleContext.getRegistry().registerTransformer(new StringToRedApple());

    t =
        muleContext
            .getRegistry()
            .lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(RedApple.class));
    assertNotNull(t);
    assertEquals(StringToRedApple.class, t.getClass());
  }
  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(
              Matchers.<DataType<?>>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;
  }
Example #3
0
 public void doTestBadReturnType(Transformer tran, Object src) throws Exception {
   tran.setReturnClass(InvalidSatsuma.class);
   try {
     tran.transform(src);
     fail("Should throw exception for bad return type");
   } catch (TransformerException e) {
     // expected
   }
 }
Example #4
0
  public void testRoundtripTransform() throws Exception {
    Transformer roundTripTransformer = this.getRoundTripTransformer();
    if (roundTripTransformer != null) {
      Object result = roundTripTransformer.transform(this.getResultData());
      assertNotNull(result);

      assertTrue(this.compareRoundtripResults(this.getTestData(), result));
    }
  }
Example #5
0
  public Transformer getTransformer() throws Exception {
    Transformer trans = createObject(DomDocumentToXml.class);
    trans.setReturnClass(String.class);

    EndpointBuilder builder = new EndpointURIEndpointBuilder("test://test", muleContext);
    builder.setEncoding("US-ASCII");
    ImmutableEndpoint endpoint =
        muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint(builder);

    trans.setEndpoint(endpoint);
    return trans;
  }
Example #6
0
  public void testTransform() throws Exception {
    Transformer trans = this.getTransformer();
    Object result = trans.transform(getTestData());
    assertNotNull(result);

    Object expectedResult = this.getResultData();
    assertNotNull(expectedResult);

    assertTrue(
        "Trasnformation result does not match expected result",
        this.compareResults(expectedResult, result));
  }
Example #7
0
  protected void applyAllTransformers(List transformers) throws TransformerException {
    if (!transformers.isEmpty()) {

      for (Object transformer1 : transformers) {
        Transformer transformer = (Transformer) transformer1;

        if (getPayload() == null) {
          if (transformer.isAcceptNull()) {
            setPayload(NullPayload.getInstance());
          } else {
            if (logger.isDebugEnabled()) {
              logger.debug(
                  "Transformer "
                      + transformer
                      + " doesn't support the null payload, exiting from transformer chain.");
            }
            break;
          }
        }

        Class srcCls = getPayload().getClass();
        if (transformer.isSourceTypeSupported(srcCls)) {
          Object result = transformer.transform(this);

          if (originalAdapter == null
              && MuleServer.getMuleContext().getConfiguration().isCacheMessageOriginalPayload()) {
            originalAdapter = adapter;
          }

          if (result instanceof MuleMessage) {
            synchronized (this) {
              adapter = ((MuleMessage) result).getAdapter();
            }
          } else {
            setPayload(result);
          }
        } else {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "Transformer " + transformer + " doesn't support the source payload: " + srcCls);
          }
          if (!transformer.isIgnoreBadInput()) {
            if (logger.isDebugEnabled()) {
              logger.debug("Exiting from transformer chain (ignoreBadInput = false)");
            }
            break;
          }
        }
      }
    }
  }
Example #8
0
  // TODO this encoding param is never used?
  protected Object getPayload(Class outputType, String encoding) throws TransformerException {
    // Handle null by ignoring the request
    if (outputType == null) {
      return getPayload();
    }

    Class inputCls = getPayload().getClass();

    // Special case where proxies are used for testing
    if (Proxy.isProxyClass(inputCls)) {
      inputCls = inputCls.getInterfaces()[0];
    }

    // If no conversion is necessary, just return the payload as-is
    if (outputType.isAssignableFrom(inputCls)) {
      return getPayload();
    }
    // Grab a list of transformers that batch out input/output requirements
    // List transformers = RegistryContext.getRegistry().lookupTransformers(inputCls, outputType);

    // The transformer to execute on this message
    Transformer transformer;
    transformer = MuleServer.getMuleContext().getRegistry().lookupTransformer(inputCls, outputType);

    // no transformers found
    if (transformer == null) {
      throw new TransformerException(
          CoreMessages.noTransformerFoundForMessage(inputCls, outputType));
    }

    // Pass in the adapter itself, so we respect the encoding
    Object result = transformer.transform(this);

    // TODO Unless we disallow Object.class as a valid return type we need to do this extra check
    if (!outputType.isAssignableFrom(result.getClass())) {
      throw new TransformerException(
          CoreMessages.transformOnObjectNotOfSpecifiedType(
              outputType.getName(), result.getClass()));
    }
    // If the payload is a stream and we've consumed it, then we should
    // set the payload on the message
    // This is the only time this method will alter the payload on the message
    if (isPayloadConsumed(inputCls)) {
      setPayload(result);
    }

    return result;
  }
  @Override
  public boolean compareResults(Object expected, Object result) {
    // MULE-4879 field ordering is not guaranteed by the JVM so we cannot compare result strings
    if (expected instanceof String || expected instanceof byte[]) {
      try {
        Transformer toObject = getRoundTripTransformer();
        expected = toObject.transform(expected);
        result = toObject.transform(result);
      } catch (Exception e) {
        fail(e.getMessage());
        return false;
      }
    }

    return super.compareResults(expected, result);
  }
Example #10
0
 public Object read(InputStream in) throws MuleException {
   if (inboundTransformer == null) {
     throw new IllegalArgumentException(
         CoreMessages.objectIsNull("inboundTransformer").getMessage());
   }
   if (inboundTransformer.isSourceTypeSupported(InputStream.class)) {
     return inboundTransformer.transform(in);
   } else {
     try {
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       IOUtils.copy(in, baos);
       return inboundTransformer.transform(baos.toByteArray());
     } catch (IOException e) {
       throw new DefaultMuleException(CoreMessages.failedToReadPayload(), e);
     }
   }
 }
Example #11
0
  // @Override
  public void testTransformerConfig() {
    // first of all test generic transformer configuration
    super.testTransformerConfig();

    Transformer t = muleContext.getRegistry().lookupTransformer("TestCompressionTransformer");
    assertNotNull(t);
    assertTrue(t instanceof TestCompressionTransformer);

    // This will only work with the MuleXml Builder other implementations
    // will have to set this proerty manually or mimic Mules behaviour
    assertEquals(
        "this was set from the manager properties!",
        ((TestCompressionTransformer) t).getBeanProperty1());
    assertEquals(12, ((TestCompressionTransformer) t).getBeanProperty2());

    assertEquals(t.getReturnClass(), java.lang.String.class);

    t = muleContext.getRegistry().lookupTransformer("TestTransformer");
    assertNotNull(t);
    assertEquals(t.getReturnClass(), byte[].class);
  }
Example #12
0
  public void write(OutputStream out, Object o, String encoding) throws MuleException {
    if (outboundTransformer == null) {
      throw new IllegalArgumentException(
          CoreMessages.objectIsNull("outboundTransformer").getMessage());
    }
    try {
      Class returnClass = outboundTransformer.getReturnClass();
      if (returnClass == null) {
        logger.warn(
            "No return class was set on transformer: "
                + outboundTransformer
                + ". Attempting to work out how to treat the result transformation");

        Object result = outboundTransformer.transform(o);

        byte[] bytes;
        if (result instanceof byte[]) {
          bytes = (byte[]) result;
        } else {
          bytes = result.toString().getBytes(encoding);
        }

        out.write(bytes);
      } else if (returnClass.equals(byte[].class)) {
        byte[] b = (byte[]) outboundTransformer.transform(o);
        out.write(b);
      } else if (returnClass.equals(String.class)) {
        String s = (String) outboundTransformer.transform(o);
        out.write(s.getBytes(encoding));
      } else {
        throw new TransformerException(CoreMessages.transformFailedFrom(o.getClass()));
      }
    } catch (IOException e) {
      throw new TransformerException(CoreMessages.transformFailedFrom(o.getClass()), e);
    }
  }
Example #13
0
  @Override
  public void processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)
      throws MuleException {
    Destination replyToDestination = null;
    MessageProducer replyToProducer = null;
    Session session = null;
    try {
      // now we need to send the response
      if (replyTo instanceof Destination) {
        replyToDestination = (Destination) replyTo;
      }
      if (replyToDestination == null) {
        super.processReplyTo(event, returnMessage, replyTo);
        return;
      }

      // This is a work around for JmsTransformers where the current endpoint needs
      // to be set on the transformer so that a JMSMessage can be created correctly (the transformer
      // needs a Session)
      Class srcType = returnMessage.getPayload().getClass();
      for (Iterator iterator = getTransformers().iterator(); iterator.hasNext(); ) {
        Transformer t = (Transformer) iterator.next();
        if (t.isSourceDataTypeSupported(DataTypeFactory.create(srcType))) {
          if (t.getEndpoint() == null) {
            t.setEndpoint(getEndpoint(event, "jms://temporary"));
            break;
          }
        }
      }
      returnMessage.applyTransformers(getTransformers());
      Object payload = returnMessage.getPayload();

      if (replyToDestination instanceof Topic
          && replyToDestination instanceof Queue
          && connector.getJmsSupport() instanceof Jms102bSupport) {
        logger.error(
            StringMessageUtils.getBoilerPlate(
                "ReplyTo destination implements both Queue and Topic "
                    + "while complying with JMS 1.0.2b specification. "
                    + "Please report your application server or JMS vendor name and version "
                    + "to dev<_at_>mule.codehaus.org or http://mule.mulesource.org/jira"));
      }

      final boolean topic = connector.getTopicResolver().isTopic(replyToDestination);
      session = connector.getSession(false, topic);
      Message replyToMessage = JmsMessageUtils.toMessage(payload, session);

      processMessage(replyToMessage, event);
      if (logger.isDebugEnabled()) {
        logger.debug(
            "Sending jms reply to: "
                + replyToDestination
                + "("
                + replyToDestination.getClass().getName()
                + ")");
      }
      replyToProducer =
          connector.getJmsSupport().createProducer(session, replyToDestination, topic);

      // QoS support
      MuleMessage eventMsg = event.getMessage();
      String ttlString = (String) eventMsg.removeProperty(JmsConstants.TIME_TO_LIVE_PROPERTY);
      String priorityString = (String) eventMsg.removeProperty(JmsConstants.PRIORITY_PROPERTY);
      String persistentDeliveryString =
          (String) eventMsg.removeProperty(JmsConstants.PERSISTENT_DELIVERY_PROPERTY);

      String correlationIDString = replyToMessage.getJMSCorrelationID();
      if (StringUtils.isBlank(correlationIDString)) {
        correlationIDString = (String) eventMsg.getProperty(JmsConstants.JMS_MESSAGE_ID);
        replyToMessage.setJMSCorrelationID(correlationIDString);
      }

      event.getService().getStatistics().incSentReplyToEvent();

      final ImmutableEndpoint endpoint = event.getEndpoint();
      if (ttlString == null && priorityString == null && persistentDeliveryString == null) {
        connector.getJmsSupport().send(replyToProducer, replyToMessage, topic, endpoint);
      } else {
        long ttl = Message.DEFAULT_TIME_TO_LIVE;
        int priority = Message.DEFAULT_PRIORITY;

        if (ttlString != null) {
          ttl = Long.parseLong(ttlString);
        }
        if (priorityString != null) {
          priority = Integer.parseInt(priorityString);
        }
        boolean persistent =
            StringUtils.isNotBlank(persistentDeliveryString)
                ? Boolean.valueOf(persistentDeliveryString)
                : connector.isPersistentDelivery();

        connector
            .getJmsSupport()
            .send(replyToProducer, replyToMessage, persistent, priority, ttl, topic, endpoint);
      }

      logger.info(
          "Reply Message sent to: "
              + replyToDestination
              + " with correlationID:"
              + correlationIDString);
    } catch (Exception e) {
      throw new DispatchException(
          JmsMessages.failedToCreateAndDispatchResponse(replyToDestination),
          returnMessage,
          null,
          e);
    } finally {
      connector.closeQuietly(replyToProducer);

      final Transaction transaction = TransactionCoordination.getInstance().getTransaction();
      if (transaction == null) {
        if (logger.isDebugEnabled()) {
          logger.debug("Closing non-TX replyTo session: " + session);
        }
        connector.closeQuietly(session);
      } else if (logger.isDebugEnabled()) {
        logger.debug("Not closing TX replyTo session: " + session);
      }
    }
  }