Salesforce Certified MuleSoft Developer II (MCD Level 2) - Practice Questions & Exam Prep

A flow consumes a message queue and must process each message exactly once, even though the broker can redeliver after a worker restart. Which design most directly enforces this?

• A. Wrap the flow body in an Async scope so processing never blocks the listener
• B. Use an Idempotent Message Validator backed by a persistent Object Store keyed on the message ID
• C. Increase the number of CloudHub workers so duplicates are spread across instances
• D. Set the connector to AUTO acknowledgement so the broker drops the message immediately

Correct: B

Exactly-once handling needs duplicate detection that survives restarts: an Idempotent Message Validator over a persistent Object Store remembers IDs it has already seen across worker lifecycles. Async only changes threading; adding workers multiplies, not dedupes, processing; and AUTO acknowledgement risks losing a message if the worker dies mid-processing - none of those make redelivered messages no-ops.

In an MUnit test you must verify that an HTTP Request inside the flow under test is never actually called, while still exercising the surrounding logic. Which approach is correct?

• A. Add an assert-equals on the payload after the flow runs
• B. Use mock-when to stub the HTTP Request processor and spy/verify-call to assert it was not invoked unexpectedly
• C. Disable the HTTP listener in the Mule configuration before the test runs
• D. Point the HTTP Request at a real sandbox endpoint and check the response code

Correct: B

MUnit isolates the flow from real I/O: mock-when replaces the HTTP Request processor with a stubbed response, and verify-call (spy) asserts how/whether a processor was invoked. assert-equals only checks output, disabling the listener does not stop an outbound Request, and hitting a real endpoint makes the test integration-dependent and non-deterministic - the opposite of a unit test.

A batch job must transform a 2 GB CSV file without loading it entirely into memory, while still allowing a downstream step to read the same records again. Which combination addresses this?

• A. Repeatable streaming with a file-store strategy on the source so the stream can be consumed more than once
• B. Set the payload to a Java ArrayList up front so every step shares one in-memory copy
• C. Wrap the batch job in a Cache scope keyed on the file name
• D. Use a For Each with a large batch size to hold all records at once

Correct: A

Repeatable streaming buffers the stream (in memory then spilling to disk via the file-store strategy) so it can be read multiple times without holding the whole 2 GB in heap. Materializing to an ArrayList or a large For Each batch defeats the memory goal, and Cache stores a computed result, not a re-readable large stream - it does not solve streaming reconsumption.