MuleSoft Certified Developer – Level 1 (Mule 4) Practice Exam

A Mule application must receive HTTP requests, transform the payload from JSON to XML, and send the result to a SOAP web service. Which components should the flow use?

1. A Scheduler trigger, a Database connector, and an email send operation
2. An HTTP Listener source, a Transform Message component with DataWeave for the JSON-to-XML conversion, and a Web Service Consumer connector for the SOAP call
3. An FTP connector, a custom Java class, and a file write operation
4. An APIkit Router, a Logger, and a VM connector

A developer needs a DataWeave transformation that converts an array of order objects into a single summary object holding the total order count and total revenue. Which approach fits?

1. Write the transformation in XML configuration instead of DataWeave
2. Use the reduce function on the input array to accumulate the count and revenue sum into one output object
3. Embed a Java class inside DataWeave for the calculation
4. Use the map function to transform each order individually

A developer is using an API-first approach and needs to define the API specification before writing any implementation code. What tool and format should they use?

1. Create a Word document describing the API endpoints
2. Write the implementation first and generate the specification afterward
3. Use Anypoint Design Center to author the spec in RAML or OAS, publish it to Anypoint Exchange, then scaffold the Mule project from the specification
4. Define the API in a spreadsheet and share it with the team

A Mule application calls an external REST API that occasionally returns 500 errors. It should retry the call up to 3 times with increasing delays before failing. What should the developer implement?

1. A Try scope that catches the error and does nothing
2. No handling — let the application crash
3. An Until Successful scope around the HTTP request, with a maximum of 3 retries and an exponential backoff frequency
4. Custom Java code to handle retries outside of Mule

An application deployed to CloudHub needs database connection strings that differ across development, staging, and production. How should the developer manage these environment-specific values?

1. Store all connection strings in one shared global properties file
2. Create a separate Mule project per environment
3. Hardcode the production database URL in the application code
4. Use property placeholders that reference environment-specific properties files or CloudHub properties, set per deployment environment

A developer must write MUnit tests for a flow that calls an external payment API. The tests must run in CI/CD without the external API being available. Which MUnit approach fits?

1. Write a separate Mule application that simulates the payment API
2. Mock the HTTP request connector using MUnit’s mock-when processor, returning test payloads for success, error, and timeout scenarios
3. Skip testing the flow because it depends on an external service
4. Test only in a staging environment with the real payment API

A flow processes large CSV files of about 1 million records, and processing each record involves an external API call. What pattern handles this volume efficiently?

1. Reduce the file to 1,000 records and discard the rest
2. Use the Batch Job scope to process records in configurable batches with parallel threads, per-record error handling, and a completion phase for summary reporting
3. Split the CSV into 1 million individual messages and run them through a For Each loop
4. Process all records synchronously in a single flow execution

A developer needs to route incoming API requests to different flows based on the HTTP method and resource path defined in the API specification. Which component fits best?

1. Separate HTTP Listeners for each method and path combination
2. A custom Java router class
3. A Choice router with a condition for each HTTP method
4. The APIkit Router, which routes requests to the matching flow automatically from the RAML/OAS specification’s resources and methods

A Mule application consumes messages from a JMS queue. If processing fails, the message should go to an error queue rather than being lost. Which error-handling configuration fits?

1. Let failed messages disappear from the queue permanently
2. Log the error and continue without preserving the failed message
3. Use an On Error Continue or On Error Propagate handler that publishes the failed message to a dead-letter (error) queue before acknowledging or rolling back the original
4. Disable error handling to simplify the flow

A developer is building an API proxy in Anypoint API Manager that must enforce rate limiting, client ID enforcement, and IP whitelisting. How should these be configured?

1. Apply API Manager policies to the proxy: a Rate Limiting policy for throttling, Client ID Enforcement for authentication, and an IP Whitelist policy for access control
2. Configure firewall rules on the server hosting the Mule application
3. Use a third-party API gateway instead of API Manager
4. Implement custom code in each Mule application for the security checks