Courseiva

SAP Certified Associate - Integration Developer (C_CPI) — Questions 151–218

218 questions total · 3 pages · All types, answers revealed

Page 2

Page 3 of 3

151
MCQhard

An integration developer is configuring an integration flow that must process messages from an SAP S/4HANA system via the SOAP adapter and then write them to an SFTP server. The developer needs the integration flow to retry the SFTP write up to three times if the SFTP server is temporarily unavailable, and to route the message to an Exception Subprocess only after all retries fail. Which configuration achieves this?

A.Wrap the SFTP call in a Local Integration Process, configure a Retry step (or a looping pattern) around it, and after the third failure throw an exception that is caught by the Exception Subprocess.
B.Configure the SFTP receiver adapter with the 'Retry on Failure' checkbox and set the retry count to three; the adapter automatically forwards the message to the Exception Subprocess after the third failure.
C.Set the SFTP receiver adapter's Retry Interval and Maximum Retries to three, and add an Exception Subprocess with an escalation endpoint that triggers after the adapter exhausts retries.
D.Set the integration flow's JMS queue to redeliver the message three times and configure the SFTP adapter to consume from the queue; after three redeliveries the message is sent to the Exception Subprocess.
AnswerA

SAP Cloud Integration does not offer a built-in retry counter on the SFTP adapter, so the reliable pattern is to place the SFTP call in a Local Integration Process and implement retry logic with a looping or scripted counter. After the configured number of failures, raising an exception routes control to the Exception Subprocess.

Why this answer

Because the SFTP receiver adapter lacks a configurable retry counter that escalates to an Exception Subprocess, the developer must implement retry logic in the flow. Placing the SFTP call in a Local Integration Process and looping with a counter, then throwing an exception after three failures, gives precise control and routes to the Exception Subprocess as required.

Exam trap

The trap here is expecting a receiver adapter to provide a built-in retry counter that escalates to an Exception Subprocess, when that logic must be built in the flow.

152
Multi-Selecthard

Which TWO actions must be performed to securely connect an SAP Cloud Integration tenant to an on-premise system using the Cloud Connector? Choose exactly two answers.

Select 2 answers
A.Configure a Cloud Connector access control list entry permitting access to the internal backend host and port
B.Install a reverse proxy directly in front of the Cloud Integration tenant runtime node
C.Register the Cloud Connector instance with the respective subaccount using an administrative user credential
D.Open inbound firewall ports on the corporate network to allow direct public internet traffic to the backend system
E.Store backend credentials permanently inside the integration flow script using plain text properties
AnswersA, C

The Cloud Connector strictly enforces an allowlist approach. Defining the internal backend system and accessible resources in the access control list is mandatory to permit secure inbound traffic from SAP Cloud Integration to reach the protected corporate network.

Why this answer

Connecting securely requires establishing a verified tunnel connection between the Cloud Connector and Cloud Integration using a technical user. Additionally, exposing the backend system resources by adding them to the Access Control list of the Cloud Connector is mandatory for authorization and routing purposes.

Exam trap

Candidates frequently forget the administrative registration step. They focus on the access control list but fail to realize the Cloud Connector must be actively registered to the subaccount via credentials.

153
MCQhard

You are designing an integration flow in SAP Cloud Integration that processes messages from a JMS queue. The queue is configured with a message retention period of 7 days. During a maintenance window, the consumer integration flow is stopped for 10 days. After the flow is restarted, what happens to messages that were enqueued during the downtime?

A.All messages are retained indefinitely until consumed.
B.Messages older than 7 days are deleted, and only those within the retention period are available.
C.Messages are moved to a dead letter queue after 7 days.
D.The queue automatically extends the retention period during downtime to prevent loss.
AnswerB

The JMS queue's message retention period determines how long messages stay in the queue. When the consumer is stopped for 10 days, messages older than 7 days are automatically removed. Only messages enqueued within the last 7 days remain available for consumption. This behaviour is expected and must be considered when planning maintenance windows.

Why this answer

JMS queues in SAP Cloud Integration enforce a configured message retention period. Messages that remain in the queue longer than this period are automatically deleted. In this scenario, with a 7-day retention and a 10-day consumer outage, messages older than 7 days are purged, and only messages enqueued within the last 7 days can be consumed after restart.

This is a critical consideration for designing reliable asynchronous integrations.

Exam trap

The trap here is assuming that JMS queues retain messages indefinitely or extend retention during downtime, when retention is strictly time-based.

154
MCQhard

An integration developer is creating an integration flow that must transform an incoming XML message into a different XML structure. The mapping requires conditional logic: if the source element OrderType equals 'EXPRESS', the target must include an ExpressFee element; otherwise, the element must be omitted. The developer wants to implement this declaratively in the Message Mapping editor. Which feature should the developer use?

A.Use a Content Modifier after the mapping to delete the ExpressFee element when OrderType is not 'EXPRESS'.
B.Configure a Router step before the mapping to branch based on OrderType and use two separate mappings.
C.Apply the standard ifWithoutElse function to the ExpressFee target element with a condition on OrderType.
D.Create a user-defined function that returns an empty string when the condition is not met and map it to ExpressFee.
AnswerC

The standard ifWithoutElse function in the Message Mapping editor evaluates a condition and creates the target element only when the condition is true, omitting it otherwise. Applying it to ExpressFee with a condition comparing OrderType to 'EXPRESS' precisely implements the required behavior declaratively. This is the intended use of the function and avoids custom code while meeting the conditional inclusion requirement.

Why this answer

The ifWithoutElse standard function is designed for conditional element creation in Message Mapping. When the condition on OrderType evaluates to true, the ExpressFee element is created; otherwise, it is omitted. This declarative approach avoids custom functions and duplicate mappings, directly fulfilling the requirement to conditionally include a target element based on source data.

Exam trap

The trap here is assuming that a user-defined function returning an empty value omits the element, when in fact it creates an empty element; only a conditional function such as ifWithoutElse omits it entirely.

155
MCQmedium

In the context of the Message Mapping editor, what is the role of the 'Function' library?

A.To store custom adapter configurations.
B.To execute custom Java code during mapping.
C.To provide reusable transformation logic for mapping fields.
D.To manage security credentials for APIs.
AnswerC

Function libraries allow developers to define and reuse common transformation logic across multiple mappings. This centralization helps maintain consistent data formatting rules throughout the integration landscape, significantly reducing the maintenance overhead associated with updating transformation logic in dozens of individual mapping files.

Why this answer

Function libraries provide pre-built logic for complex data transformations, such as string manipulation, mathematical calculations, and date formatting. By using these functions, developers can implement custom transformation rules without writing manual code. This is important for ensuring consistency and reducing development time, as standard functions are thoroughly tested and optimized for performance within the SAP Integration Suite environment.

Exam trap

Test-takers frequently mistake function libraries for external web service connections or custom mapping code writing tools, overlooking their primary purpose as pre-built reusable logic containers.

156
MCQhard

An integration developer is using a Groovy script in SAP Cloud Integration to parse a large XML payload. The script uses the XmlSlurper class to process the payload. During testing, the developer notices that the integration flow runs out of memory when processing very large messages. Which action should the developer take to resolve this?

A.Replace XmlSlurper with XmlParser to reduce memory consumption.
B.Increase the heap size of the tenant by contacting SAP support.
C.Use a streaming XML parser such as StAX (Streaming API for XML) in the Groovy script instead of XmlSlurper.
D.Split the XML payload into smaller messages using an Iterating Splitter before the Groovy script.
AnswerC

StAX provides a streaming, pull-based approach to XML parsing, allowing the script to process the XML incrementally without loading the entire document into memory. This significantly reduces memory footprint and is the recommended way to handle large XML payloads in Groovy scripts on SAP Cloud Integration. It avoids the out-of-memory errors caused by DOM-based parsers like XmlSlurper.

Why this answer

XmlSlurper loads the entire XML document into memory, causing out-of-memory errors with very large payloads. StAX, a streaming parser, processes XML incrementally, keeping memory usage low. Increasing heap or switching to XmlParser does not solve the problem, and splitting the payload may not be appropriate if the script requires the whole document.

StAX is the correct technical solution.

Exam trap

The trap here is assuming that XmlParser uses less memory than XmlSlurper, when in fact both are DOM-based and memory-intensive; only streaming parsers like StAX address the root cause.

157
MCQmedium

An integration developer is configuring a Message Mapping in SAP Cloud Integration. The source structure contains a repeating node <Items> with child elements, and the target requires the same repeating node but only for items where the <Status> element equals 'ACTIVE'. The developer wants to filter the repeating node during mapping without altering the source message. Which approach should be used?

A.Use a Content Modifier step to set a header with the filter condition, then reference that header in the mapping.
B.Apply a Filter step in the integration flow before the Message Mapping step to remove inactive items.
C.Use a standard user-defined function in the Message Mapping that returns a boolean and apply it as a condition on the target repeating node.
D.Use the Filter node in the Message Mapping editor on the source repeating node and define an XPath condition such as Status = 'ACTIVE'.
AnswerD

The Filter node available in the graphical Message Mapping editor allows you to apply a condition directly to a repeating source node. You can specify an XPath expression like Status = 'ACTIVE' so that only matching occurrences are mapped to the target. This filters within the mapping itself, leaving the original source message unchanged and meeting the scenario requirement precisely.

Why this answer

The Filter node in the message mapping editor is designed exactly for this purpose: it applies an XPath condition to a repeating source node so only matching instances are mapped. This keeps the filtering inside the mapping, does not modify the source payload, and avoids extra integration flow steps. Other options either operate at the wrong level or are not supported for node-level filtering.

Exam trap

The trap here is assuming that a Filter step in the integration flow or a Content Modifier can filter individual repeating node instances, when only the Filter node inside the Message Mapping operates at that granularity.

158
Multi-Selectmedium

An integration developer is configuring a Groovy script step in an integration flow to read a custom header named BusinessUnit and write its value into the message body. The script must also handle the case where the header is missing. Which TWO statements about the message model and API are correct for this scenario? (Choose two.)

Select 2 answers
A.The script can retrieve the header using message.getHeaders().get("BusinessUnit") and must check for null before using the value.
B.Headers in the message model are immutable, so the script must use a Content Modifier step to read the BusinessUnit header value.
C.The script must use message.getBody() to obtain the header value, because headers and body share the same storage in the message model.
D.The script can only read headers that were defined in the integration flow's sender adapter, and custom headers added by a Content Modifier are invisible to Groovy.
E.The script can set the message body by calling message.setBody() with a String, and this replaces the entire body content.
AnswersA, E

In SAP Cloud Integration Groovy scripts, message headers are accessed through the Message API's getHeaders() method, which returns a map-like structure. Calling get("BusinessUnit") returns null when the header is absent, so the script must perform a null check to avoid a NullPointerException or writing the literal string null into the body. This is the correct way to read a custom header safely.

Why this answer

Groovy scripts in SAP Cloud Integration access headers through the Message API's getHeaders() method, returning null when a header is absent, so a null check is essential. The script writes results using setBody(), which replaces the entire payload. Headers and body are separate message components, and headers set by earlier steps such as a Content Modifier remain visible to the script, making direct header reads both possible and correct.

Exam trap

The trap here is believing that headers set by a Content Modifier are not visible to Groovy scripts, when in fact all headers on the message are accessible through the Message API.

159
MCQeasy

An integration developer needs an integration flow in SAP Cloud Integration to be triggered automatically at a fixed interval so it can poll an internal system's OData service every hour without any external caller. Which sender adapter should be configured for this integration flow?

A.SOAP sender adapter
B.Timer (Simple) sender adapter
C.HTTPS sender adapter
D.OData sender adapter
AnswerB

The Timer (Simple) sender adapter starts an integration flow on a schedule defined by a simple interval, such as every hour, without any inbound message. It is designed exactly for time-driven polling scenarios where the flow itself retrieves data from a backend. Configuring the interval to one hour satisfies the unattended hourly execution requirement with no external caller involved.

Why this answer

A time-driven integration flow that must run unattended and retrieve data on a fixed cadence needs a sender adapter capable of scheduling. The Timer (Simple) sender adapter fires the flow at configured intervals without any external request, which matches the hourly polling requirement. Caller-driven adapters such as HTTPS, SOAP, and OData remain idle until invoked and provide no scheduling, so they cannot satisfy the scenario.

Exam trap

The trap here is confusing a receiver-side polling adapter with a sender-side scheduling adapter, when only the timer sender can start a flow without an inbound call.

160
MCQhard

Refer to the exhibit. ```groovy import com.sap.gateway.ip.core.customdev.util.Message; import groovy.json.JsonSlurper; import groovy.json.JsonBuilder; def Message processData(Message message) { def body = message.getBody(java.lang.String as Class); def jsonSlurper = new JsonSlurper(); def data = jsonSlurper.parseText(body); data.status = "PROCESSED"; def jsonBuilder = new JsonBuilder(data); message.setBody(jsonBuilder.toString()); return message; } ``` A Groovy script shown in the exhibit is executed within an integration flow to update an incoming JSON payload. What is the primary execution behavior and potential runtime risk associated with this script?

A.The script streams the JSON content incrementally using a pull parser, ensuring minimal memory overhead for payloads exceeding 100 megabytes.
B.The script modifies the payload in-memory by parsing the JSON text, updating a property, and serializing it back to the message body.
C.The script fails at runtime because the com.sap.gateway.ip.core.customdev.util.Message class does not support the getBody method with a Class parameter.
D.The script throws a ClassCastException because JsonBuilder cannot serialize modified Groovy maps back into valid JSON string formats.
AnswerB

The script correctly reads the message body as a string, instantiates a JsonSlurper to parse the text into a navigable data structure, modifies the status field, and uses JsonBuilder to serialize the updated map back into the outgoing message body.

Why this answer

The script parses an incoming JSON string into an in-memory map structure, modifies an attribute, and serializes it back into a string using standard Groovy JSON libraries. The primary runtime risk involves handling extremely large JSON payloads, which can cause excessive memory consumption and trigger OutOfMemoryError exceptions on the worker node.

Exam trap

Candidates often overlook the memory overhead of parsing large JSON strings into memory-resident maps. They assume Groovy scripts are always efficient, failing to account for heap space limits on large payloads.

161
MCQeasy

An integration developer is creating an integration flow that must convert a JSON payload to XML. The JSON contains an array of objects under the root element 'orders'. Which step should be used to perform this conversion?

A.Content Modifier step with a JSON to XML expression.
B.JSON to XML Converter step.
C.Groovy script step using JsonSlurper and XmlBuilder.
D.Message Mapping step with a JSON to XML mapping.
AnswerB

The JSON to XML Converter step in SAP Cloud Integration is specifically designed to convert a JSON payload into XML format. It handles the conversion automatically, including arrays and nested objects. This is the standard and most efficient way to achieve the required transformation without custom scripting.

Why this answer

The JSON to XML Converter step is a built-in feature in SAP Cloud Integration that converts JSON payloads to XML. It is the simplest and most direct method, requiring no custom scripting or mapping. It correctly handles arrays and nested structures, making it ideal for this scenario.

Exam trap

The trap here is assuming that Message Mapping or a Groovy script is needed for JSON to XML conversion, when a dedicated converter step exists.

162
MCQhard

An integration developer is building an integration flow that uses a Groovy script to modify the message body. The script must access a header named 'CustomerID' and set it as a property named 'CustID' for later use in the flow. Which code snippet correctly accomplishes this in SAP Cloud Integration?

A.def custId = message.getHeaders().get("CustomerID"); message.setHeader("CustID", custId);
B.def custId = message.getProperties().get("CustomerID"); message.setProperty("CustID", custId);
C.def custId = message.getHeader("CustomerID"); message.setProperty("CustID", custId);
D.def custId = message.getHeaders().get("CustomerID"); message.setProperty("CustID", custId);
AnswerD

In SAP Cloud Integration Groovy scripts, the 'message' object provides methods to access headers and set properties. 'getHeaders().get("CustomerID")' retrieves the header value, and 'setProperty("CustID", custId)' sets an exchange property. This is the correct API for the scenario, ensuring the header value is stored as a property for subsequent steps.

Why this answer

The correct Groovy snippet must read the header 'CustomerID' using the appropriate API and then set an exchange property 'CustID'. The 'message' object in SAP Cloud Integration provides 'getHeaders().get()' for headers and 'setProperty()' for properties. Using 'getHeader' or reading from properties would fail, and setting a header instead of a property would not meet the requirement.

Thus, the snippet that uses 'getHeaders().get()' and 'setProperty()' is correct.

Exam trap

The trap here is assuming that headers and properties are interchangeable or that the method 'getHeader' exists, when in fact they serve different purposes and only 'getHeaders().get()' is valid.

163
MCQhard

An integration developer is troubleshooting an integration flow that uses a Groovy script step. The script must read a message header named 'CustomerID' and write its value into the message body. The script currently throws a NullPointerException when the header is absent. Which approach correctly handles the missing header while preserving the script's intent?

A.Use message.getHeaders().get('CustomerID').toString() and assign the result to the body
B.Use message.getHeaders().get('CustomerID') and check for null before assigning, defaulting to an empty string if absent
C.Use message.getHeader('CustomerID') and assign the result to the body without further processing
D.Use message.getHeaders().get('CustomerID') and assign the result directly to the body without a null check
AnswerB

Retrieving the header with get('CustomerID') returns null when the header is missing. Adding a null check and defaulting to an empty string prevents the NullPointerException while preserving the intent to write the header value to the body. This is the correct defensive programming approach in a Groovy script step within SAP Cloud Integration.

Why this answer

When a header may be absent, retrieving it with get('CustomerID') returns null. The script must explicitly check for null and provide a fallback value before using the result. Defaulting to an empty string avoids the NullPointerException and maintains the script's purpose of writing the header value to the body.

Other approaches either call methods on null or use an invalid API, so they fail to handle the missing header safely.

Exam trap

The trap here is assuming that a missing header returns an empty string rather than null, which leads to an unhandled NullPointerException.

164
MCQmedium

An integration developer is configuring a SOAP receiver adapter in SAP Cloud Integration to call an external web service that requires WS-Security with a username token. The developer needs to ensure the credentials are not stored in plain text in the integration flow and can be changed without redeploying. What is the appropriate configuration?

A.Create a User Credentials artifact in the Security Material monitor, reference it from the SOAP adapter's WS-Security configuration, and update the artifact when credentials change.
B.Enter the username and password directly in the SOAP adapter's WS-Security configuration fields and redeploy the flow whenever credentials change.
C.Use a Secure Store artifact to hold the password only, and hardcode the username in the adapter because usernames are not sensitive.
D.Store the credentials in a Partner Directory parameter and reference the parameter using a dynamic expression in the SOAP adapter.
AnswerA

User Credentials artifacts are stored securely in the tenant's security material and referenced by name from adapters. The SOAP adapter's WS-Security settings can use this artifact for the username token, so credentials are never exposed in the flow and can be rotated by updating the artifact without redeploying the integration flow.

Why this answer

The SOAP receiver adapter supports WS-Security username tokens backed by a User Credentials artifact stored in the tenant's Security Material. Referencing that artifact keeps the password out of the integration flow and allows credential rotation by updating the artifact, with no redeployment required. This satisfies both the security and operational requirements for calling the external service.

Exam trap

The trap here is believing that the Secure Store or Partner Directory is the correct place for WS-Security credentials, when the SOAP adapter expects a User Credentials artifact.

165
MCQhard

You are configuring a JMS receiver adapter in SAP Cloud Integration to send messages to a queue. The queue is configured with a maximum message size of 10 MB. During testing, you notice that messages larger than 10 MB are being rejected and the integration flow fails. Which action should you take to handle this situation gracefully?

A.Add a Splitter step before the JMS receiver adapter to divide the large message into smaller messages that are within the size limit.
B.Enable the 'Split Message' option in the JMS receiver adapter to break large messages into smaller chunks.
C.Configure a retry mechanism with a backoff policy in the JMS receiver adapter to resend the message until it fits.
D.Use a Content Modifier to set the JMS message size property to a larger value before the JMS receiver adapter.
AnswerA

The Splitter step can break a large payload into multiple smaller messages based on an XPath expression or other criteria. Each resulting message will be smaller and can be sent individually to the JMS queue, respecting the 10 MB limit. This is the correct approach to handle large messages when the queue has a size restriction, ensuring all data is processed without rejection.

Why this answer

When a JMS queue enforces a maximum message size, the integration flow must ensure that messages sent do not exceed that limit. Splitting the large message into smaller parts using a Splitter step allows each part to be sent separately and successfully. This is a standard pattern for handling large payloads with size-constrained receivers.

Exam trap

The trap here is thinking that the JMS adapter can automatically split messages or that retrying will solve a size limit issue, when in fact the split must be done explicitly in the flow.

166
MCQeasy

An integration developer is working on an integration flow in SAP Cloud Integration that uses a Message Mapping step. The developer needs to test the mapping with sample input and verify the output without deploying the integration flow. Which tool in SAP Cloud Integration should the developer use?

A.Use the 'Test' button in the Message Mapping editor to provide sample input and view the output.
B.Deploy the integration flow to a test tenant and use the 'Trace' feature in the Monitor section.
C.Use the 'Simulate' feature in the integration flow editor.
D.Use the 'Groovy Script' step to write a test script that calls the mapping.
AnswerA

The Message Mapping editor in SAP Cloud Integration includes a 'Test' button that allows developers to input sample XML or JSON data and execute the mapping to see the resulting output. This is a built-in testing feature that does not require deploying the integration flow. It is the standard way to verify mapping logic during development. This directly addresses the scenario of testing the mapping without deployment.

Why this answer

The Message Mapping editor in SAP Cloud Integration provides a 'Test' button that lets developers supply sample input and immediately see the mapped output. This allows testing of the mapping logic without deploying the integration flow. It is the most efficient and standard way to validate mappings during development.

Other options require deployment or custom scripting, which are unnecessary for this purpose.

Exam trap

The trap here is assuming that testing a mapping requires deploying the integration flow or using external tools, when the mapping editor itself has a built-in test feature.

167
Multi-Selecthard

An integration developer is configuring exception handling in an integration flow. The flow calls an external REST endpoint, and the developer wants to catch specific HTTP errors, log them, and then continue processing with a fallback response. The developer plans to use an Exception Subprocess. Which two actions are valid within an Exception Subprocess to achieve this? (Choose two.)

Select 2 answers
A.Use a Splitter step to break the error message into multiple parts for logging
B.Use a Request Reply step to call the same REST endpoint again without any changes
C.Use a Content Enricher step to merge the original request with the error response
D.Use a Content Modifier to set a fallback message body and headers
E.Use a Groovy script to inspect the exception and write details to the message log
AnswersD, E

Within an Exception Subprocess, the developer can add steps to build a fallback response. A Content Modifier can replace the body with a static or expression-based fallback and set headers or properties. This allows the flow to continue with a defined response instead of failing, which matches the requirement to continue processing after logging the error.

Why this answer

An Exception Subprocess can contain any step, so a Content Modifier can build a fallback body and headers, and a Groovy script can inspect and log the exception. These two actions together allow the developer to log specific HTTP errors and then continue with a defined fallback response. Retrying blindly, splitting the error, or enriching the message do not provide logging and fallback behavior in this context.

Exam trap

The trap here is assuming that any step inside an Exception Subprocess automatically handles the error, when only steps that log or build a fallback actually achieve the goal.

168
MCQmedium

An integration developer needs an integration flow in SAP Cloud Integration to call an external REST API that requires an OAuth 2.0 client credentials token. The token endpoint and client credentials are stored as a Security Material of type OAuth2 Client Credentials. Which step configuration correctly obtains and attaches the token to the outbound request?

A.Add a Request Reply step with the SOAP receiver channel configured to use the OAuth2 Client Credentials security material.
B.Add a Content Modifier that sets an Authorization header with a Basic authentication value derived from the client ID and secret.
C.Add a Request Reply step with the HTTP receiver channel configured to use the OAuth2 Client Credentials security material, so the adapter fetches and applies the token automatically.
D.Add a Groovy script that reads the client credentials from a Partner Directory entry, performs a POST to the token endpoint, and sets the Authorization header manually.
AnswerC

When an HTTP receiver channel references an OAuth2 Client Credentials security material, the adapter retrieves a token from the configured token endpoint and adds the Authorization header to the outbound request. This is the built-in mechanism and avoids custom token handling in scripts. It satisfies the requirement with minimal configuration and correct credential storage.

Why this answer

The HTTP receiver adapter can consume an OAuth2 Client Credentials security material directly. During message processing it requests a token from the configured token endpoint and injects the bearer token into the Authorization header, so the developer does not need custom scripting. This is the supported and least error-prone configuration.

Exam trap

The trap here is manually scripting token retrieval or using Basic authentication when the HTTP receiver adapter can handle OAuth 2.0 client credentials automatically through a security material reference.

169
MCQhard

A developer needs to call an SAP S/4HANA OData V2 service that requires principal propagation from an on-premise SAP NetWeaver Gateway. The Cloud Integration tenant is connected through Cloud Connector. Users authenticate to Cloud Integration with their SAP IAS identity, and the backend expects the SAP user context. Which combination of configuration elements is required to make principal propagation work end to end?

A.Configure the OData receiver with authentication method 'Basic Authentication' and store the SAP backend user credentials in a User Credentials artifact in the tenant.
B.Configure the OData receiver with authentication method 'Client Certificate' and import the tenant's keystore certificate into the backend's trusted CA list.
C.Configure the OData receiver with authentication method 'OAuth 2.0 Client Credentials' and map the IAS user to a backend service user in the Cloud Connector principal mapping table.
D.Configure the OData receiver with authentication method 'Principal Propagation' and enable the 'System Logon' in Cloud Connector with the X.509 certificate trust between Cloud Connector and the backend.
AnswerD

Principal propagation relies on the Cloud Connector establishing a short-lived X.509 certificate on behalf of the logged-in user, which the backend trusts. Selecting Principal Propagation on the receiver adapter and configuring System Logon trust in Cloud Connector is the standard path. Without both sides, the backend receives an anonymous or technical-user context instead of the propagated user identity.

Why this answer

Principal propagation forwards the logged-in user's identity to the on-premise backend by having Cloud Connector issue a short-lived certificate for that user, which the backend trusts. The receiver adapter must be set to Principal Propagation, and Cloud Connector must be configured for System Logon with the correct trust configuration. Neither side alone is sufficient, and alternatives like Basic or Client Certificate authenticate the application rather than the user.

Exam trap

The trap here is believing that any authentication method that reaches the backend will propagate the user, when only the Principal Propagation method with Cloud Connector System Logon trust does so.

170
MCQmedium

An integration developer is designing an integration flow that processes purchase order messages. The flow must route messages to different receivers based on the value of the CompanyCode element in the XML payload, and the routing conditions must be editable by a business analyst without redeploying the flow. Which approach best satisfies the requirement?

A.Add a Content Modifier step that writes the CompanyCode to a header, then use a Multicast step with two branches.
B.Configure a General Splitter step and a Message Mapping step that reads the CompanyCode from a partner directory.
C.Use a Router step with conditions that reference a Partner Directory parameter, and maintain the routing values in the Partner Directory.
D.Use a Router step with XPath expressions that reference a Value Mapping artifact deployed in the tenant.
AnswerC

A Router step can evaluate expressions that read Partner Directory parameters, so the routing values live outside the flow model. A business analyst can update those parameters in the Partner Directory at runtime without redeploying, and the Router picks up the new values on subsequent messages, satisfying the no-redeploy requirement.

Why this answer

Referencing Partner Directory parameters from a Router step externalizes the routing values, so a business analyst can change them in the Partner Directory without a flow redeployment. The Router still evaluates conditions per message, but the values it compares against are maintained outside the integration flow model, which is exactly what the requirement demands.

Exam trap

The trap here is assuming that a Router step always embeds its conditions in the flow model, when conditions can instead reference externally maintained Partner Directory parameters.

171
MCQeasy

An integration developer is creating a new integration flow in SAP Cloud Integration to transform an incoming XML order into a JSON payload for a REST receiver. The developer wants to define the transformation logic visually by dragging source and target fields onto a canvas. Which step type should be used?

A.Groovy Script step containing a hand-written script that builds the JSON output
B.Message Mapping step referencing an operation mapping created in the graphical mapping editor
C.XSLT Mapping step with a stylesheet uploaded from the local file system
D.Content Modifier step with an expression that rewrites the payload body
AnswerB

The Message Mapping step in an integration flow references a mapping artifact, such as a message mapping, that is authored in the graphical editor by dragging source structure fields to target structure fields. This matches the requirement to define transformation logic visually on a canvas and is the standard approach for XML-to-JSON structural transformation in SAP Cloud Integration.

Why this answer

The graphical message mapping editor is the visual environment for defining field-to-field transformations, and an integration flow consumes such a mapping through a Message Mapping step. This step references the mapping artifact and applies it at runtime, converting the incoming XML order into the JSON structure the REST receiver expects without hand-written code.

Exam trap

The trap here is equating any payload-altering step, such as a Content Modifier or a script, with the graphical field-mapping capability that the scenario explicitly asks for.

172
MCQmedium

An integration developer is building an integration flow in SAP Cloud Integration that must call a SOAP web service exposed by an SAP S/4HANA system. The WSDL defines a request-reply operation and the service requires WS-Security UsernameToken authentication. The developer has imported the WSDL as an external definition and now needs to configure the outbound call. Which adapter type should the developer use to consume this SOAP service?

A.SOAP (SOAP 1.x) receiver adapter
B.OData V2 receiver adapter
C.IDoc receiver adapter
D.HTTP receiver adapter with SOAP action header
AnswerA

The SOAP receiver adapter in SAP Cloud Integration is purpose-built to consume SOAP 1.x and SOAP 1.2 web services described by a WSDL. It supports WS-Security UsernameToken, X.509 token, and SAML assertions out of the box, and it can reference an imported WSDL-based external definition to generate the request payload. This directly satisfies the S/4HANA SOAP service with UsernameToken authentication.

Why this answer

Consuming a WSDL-described SOAP service in SAP Cloud Integration requires the SOAP receiver adapter, which natively supports SOAP 1.x/1.2 and WS-Security UsernameToken. Importing the WSDL as an external definition lets the adapter bind to the correct operation and construct the SOAP envelope. Adapters such as OData, HTTP, and IDoc do not understand WSDL operations or WS-Security headers, so they cannot satisfy the authentication and message format requirements of this S/4HANA service.

Exam trap

The trap here is assuming any HTTP-based adapter can call a SOAP service just because SOAP runs over HTTP, ignoring that WSDL binding and WS-Security UsernameToken require the dedicated SOAP adapter.

173
MCQmedium

You are developing an integration flow in SAP Cloud Integration that reads a message from a JMS queue. The queue is configured with a message retention period of 2 days. A downstream receiver is temporarily unavailable, and messages are not being consumed. After 2 days, what happens to the messages in the queue?

A.The messages are automatically moved to a dead letter queue for later processing.
B.The messages remain in the queue indefinitely until consumed.
C.The messages are deleted from the queue and cannot be retrieved.
D.The messages are archived to a persistent store for auditing purposes.
AnswerC

In SAP Cloud Integration, the JMS queue's message retention period defines how long messages are kept. Once the retention period expires, the messages are automatically deleted from the queue. There is no built-in recovery mechanism, so any unconsumed messages are lost. This is the correct behavior for the given scenario.

Why this answer

The JMS queue in SAP Cloud Integration enforces a message retention period. When that period elapses, messages are automatically deleted and cannot be recovered. This prevents indefinite accumulation of unconsumed messages.

Therefore, the messages are deleted from the queue and cannot be retrieved. The other options describe behaviors that are not default or require additional configuration.

Exam trap

The trap here is assuming that expired messages are moved to a dead letter queue or archived, when in fact they are simply deleted.

174
MCQeasy

An integration developer is creating an integration flow that must log the message payload at a specific point for debugging purposes. The developer wants the logged content to be visible in the tenant's message processing log without storing the full payload permanently. Which step should be used?

A.Content Modifier with the body logged as a header
B.Message Mapping step with trace logging enabled
C.Message Log step configured to log the payload at that position
D.Groovy Script step writing to the tenant log via the script API
AnswerC

The Message Log step writes the current message payload to the message processing log at the point where it is placed. It is the built-in mechanism for capturing payloads for debugging, and its log level and content can be configured. This directly satisfies the requirement without custom code or altering headers.

Why this answer

The Message Log step captures the message payload into the message processing log at the exact position it is placed in the flow. It is the purpose-built step for debugging payloads and avoids custom scripting or header manipulation. The other options either do not log or require custom code and risk side effects.

Exam trap

The trap here is assuming a Content Modifier or script is needed to log payloads, when the Message Log step is the built-in component designed for that purpose.

175
MCQmedium

An integration developer is configuring an HTTPS sender adapter in SAP Cloud Integration to receive messages from an external partner. The partner requires mutual TLS authentication and will present a client certificate. The developer must ensure that only certificates issued by the partner's specific Certificate Authority are accepted. Which configuration step achieves this requirement?

A.Set the sender adapter to use 'Role-Based Authentication' and assign the partner to a predefined role with certificate mapping.
B.Upload the partner's server certificate to the tenant keystore as a trusted certificate and enable 'Client Certificate Authentication'.
C.Configure OAuth 2.0 client credentials with the partner's client ID and secret in the sender adapter.
D.Enable 'Client Certificate Authentication' and upload the partner's CA certificate as a trusted certificate in the tenant's keystore.
AnswerD

The HTTPS sender adapter supports client certificate authentication. By enabling this option and importing the partner's CA certificate into the tenant keystore as a trusted certificate, the tenant validates that the client certificate is signed by that CA, ensuring only authorized partners can connect.

Why this answer

Mutual TLS authentication in SAP Cloud Integration requires the sender adapter to be configured for client certificate authentication and the tenant keystore to trust the CA that issued the client certificate. Importing the partner's CA certificate ensures that any certificate signed by that CA is accepted, fulfilling the requirement without importing individual certificates.

Exam trap

The trap here is confusing server certificate validation with client certificate validation; the partner's server certificate is not relevant when the partner acts as the client presenting a certificate.

176
MCQmedium

An integration developer is configuring a Message Mapping in SAP Cloud Integration. The target structure requires that a repeating node named Items be populated only when the source field OrderStatus equals 'RELEASED'. Which mapping construct should be used to evaluate the condition and control whether the target node is created?

A.A user-defined function invoked from the target Items node with a queue-based approach
B.A standard removeContexts function applied to the source OrderStatus field
C.A standard createIf function with the condition OrderStatus='RELEASED' on the target Items node
D.A standard ifWithoutElse function placed on the parent node of Items
AnswerC

The createIf function evaluates a boolean expression and creates the target node only when the condition is true. In this scenario, placing createIf on the Items node with the expression OrderStatus='RELEASED' ensures the repeating node is instantiated only for released orders. This is the standard, supported way to conditionally create nodes in a Message Mapping.

Why this answer

Conditional node creation in a Message Mapping is achieved with the createIf function, which evaluates a boolean expression and instantiates the target node only when the expression returns true. In this scenario, the Items node must exist only when OrderStatus equals 'RELEASED', so createIf on that node with the appropriate expression is the correct construct. Other functions handle context, iteration, or value transformation but do not conditionally create nodes.

Exam trap

The trap here is confusing conditional value mapping functions such as ifWithoutElse with conditional node creation, which requires createIf.

177
MCQmedium

An integration flow needs to process incoming XML payloads, transform them using XSLT, and route messages based on a header value. Which step sequence ensures proper execution inside SAP Cloud Integration?

A.Router step followed by XSLT Mapping and Content Modifier
B.XSLT Mapping step followed by Router and Content Modifier
C.Content Modifier step followed by XSLT Mapping and Router
D.Router step followed by Content Modifier and XSLT Mapping
AnswerC

Initializing required headers using the Content Modifier ensures data is available for downstream components. Performing the XSLT mapping transforms the message structure correctly before the Router step evaluates the headers to direct the message flow accurately.

Why this answer

Placing the Content Modifier first allows setting necessary headers before routing occurs. The XSLT Mapping step then transforms the payload structure accordingly. Finally, the Router step evaluates the previously established header values to direct the message flow correctly, ensuring all prerequisites are met before evaluation takes place in the route branches.

Exam trap

Candidates often place the Router before the Content Modifier, which causes routing conditions to fail because the required header values have not yet been defined or populated in the message exchange.

178
Multi-Selecthard

An integration developer is implementing error handling in an integration flow. The flow calls an external system that may return HTTP 500 errors. The developer wants to retry the call up to three times with a delay between attempts, and if all retries fail, send an alert and stop processing. Which two steps or configurations are required to achieve this? (Choose two.)

Select 2 answers
A.Configure the external call step with a retry interval and maximum retries.
B.Configure an alerting mechanism in the Exception Subprocess to send a notification after retries are exhausted.
C.Use a Groovy script to catch exceptions and implement a retry loop with sleep.
D.Use an Exception Subprocess with a Timer step to implement retries.
E.Add a Content Modifier step to set a header indicating the retry count.
AnswersA, B

Many adapter steps in SAP Cloud Integration, such as the HTTP receiver, allow you to configure retry settings directly. By setting the maximum retries to three and specifying a retry interval, the adapter automatically retries the call upon failures like HTTP 500. This is the simplest way to implement retries without custom logic.

Why this answer

To achieve retries with a delay, configure the adapter's retry settings (maximum retries and retry interval) directly on the external call step. This handles the retry logic automatically. If all retries fail, the flow will raise an exception, which can be caught by an Exception Subprocess.

There, you can send an alert and ensure processing stops. Combining adapter-level retries with an Exception Subprocess for alerting fulfills the requirements without custom scripting.

Exam trap

The trap here is overcomplicating the solution by using scripts or Exception Subprocesses for retries, when the adapter itself provides built-in retry configuration that is simpler and more reliable.

179
MCQeasy

Which component in SAP Integration Suite is used to define and store reusable mappings, such as Value Mappings, across multiple integration flows?

A.Integration Adapter.
B.Value Mapping artifact.
C.Security Material.
D.Message Store.
AnswerB

The Value Mapping artifact is the designated component for storing cross-reference tables. It allows developers to map disparate values between systems in a centralized, reusable way, which is essential for maintaining data integrity and simplifying the configuration of complex integration scenarios across the enterprise landscape.

Why this answer

Value Mappings are stored within the Integration Package and are explicitly designed for reusability. By maintaining mapping tables in a central location, you ensure data consistency across different scenarios. This is a critical development practice because it reduces maintenance effort, minimizes errors caused by duplicate data definitions, and simplifies updates when business codes change across integrated enterprise systems.

Exam trap

Candidates often confuse 'Value Mapping' with 'Data Store' or 'Global Variables,' incorrectly assuming that standard storage components are intended for maintaining reusable business code mappings across different integration flows.

180
MCQmedium

You are configuring an HTTPS sender adapter in SAP Cloud Integration. The integration flow must accept requests from an external partner, and you need to authenticate the partner using a client certificate. Which keystore artifact must you create and deploy to enable this authentication?

A.A Java keystore containing your own private key and certificate, deployed as a Keystore artifact.
B.An OAuth2 client credentials artifact deployed as a Security Material artifact.
C.A PGP key pair deployed as a PGP Keys artifact.
D.A Java keystore (JKS) containing the partner's public certificate, deployed as a Keystore artifact.
AnswerD

A Keystore artifact in SAP Cloud Integration stores public certificates used to validate incoming client certificates. You must import the partner's public certificate into a Keystore and deploy it. The HTTPS sender adapter then references this keystore to trust the partner's certificate during the TLS handshake, enabling client certificate authentication.

Why this answer

For an HTTPS sender adapter to authenticate a partner using a client certificate, the integration flow must trust the partner's certificate. This is achieved by deploying a Keystore artifact that contains the partner's public certificate. The sender adapter references this keystore to validate the client certificate during the TLS handshake.

Using a keystore with your own private key is for outbound scenarios, and PGP or OAuth2 artifacts serve different security purposes.

Exam trap

The trap here is confusing keystores used for inbound client certificate validation with those used for outbound client authentication, leading to selecting your own private key instead of the partner's public certificate.

181
MCQhard

An integration developer is configuring a Request Reply step in an integration flow that calls an external REST API. The API returns a JSON response that must be merged with the original request payload before being sent to the receiver. Which pattern should the developer use?

A.Use a Splitter step to separate the request and response, then a Gather step to merge them.
B.Use a Multicast step with two branches, one calling the API and one retaining the original, then rely on the multicast to merge the outputs.
C.Use a Content Enricher step to merge the API response into the original message.
D.Use a Request Reply step, then a Message Mapping or Groovy Script step to combine the response with the saved original payload.
AnswerD

The Request Reply step sends the request and receives the response, but it replaces the message body by default. To merge, the developer must preserve the original payload, for example in a property or by using a multicast before the call, and then combine it with the response using a mapping or script. This is the correct pattern for response merging.

Why this answer

A Request Reply step replaces the message body with the API response, so the original request payload must be preserved separately and then merged with the response using a mapping or script. This is the standard enrichment pattern in SAP Cloud Integration.

Exam trap

The trap here is assuming Request Reply automatically retains the original payload or that Multicast merges branch outputs, when in fact the body is replaced and merging must be designed explicitly.

182
MCQmedium

An integration developer needs to expose an integration flow in SAP Cloud Integration as an HTTPS endpoint that external partners can call. The partner requires mutual TLS authentication and the developer must ensure only authorized clients can invoke the flow. Which configuration should be applied to the HTTPS sender adapter?

A.Set the adapter to Basic authentication and store partner credentials in a User Credentials artifact
B.Configure the sender adapter with Client Certificate authentication and assign a role to the certificate
C.Enable CSRF protection and require a session cookie
D.Use OAuth 2.0 client credentials with a generated client ID and secret
AnswerB

The HTTPS sender adapter supports client certificate authentication, where the partner presents an X.509 certificate during the TLS handshake. By mapping that certificate to a user and assigning an appropriate role, the tenant enforces mutual TLS and authorization. This directly satisfies both the mutual TLS and authorized-clients requirements.

Why this answer

Mutual TLS requires the client to present a certificate during the handshake, which the HTTPS sender adapter supports through Client Certificate authentication. Mapping the certificate to a user and role ensures only authorized partners can invoke the flow. Token-based or password-based options do not provide the certificate handshake the partner demands.

Exam trap

The trap here is equating any strong authentication method with mutual TLS, when only client certificate authentication actually requires the partner to present an X.509 certificate.

183
MCQhard

When designing a Groovy script to handle complex payload manipulation, which object should you utilize to access the dynamic properties and headers within the Integration flow context?

A.The System object.
B.The Message object.
C.The CamelContext object.
D.The Logger object.
AnswerB

The Message object is specifically designed to provide access to the current exchange's headers, properties, and body content. It is the entry point for all custom Groovy scripting within SAP Integration Suite, allowing developers to perform complex logic that standard components cannot handle natively during runtime.

Why this answer

The Message object is the primary interface in Groovy scripts for interacting with the current message processing context. By using methods such as getHeaders(), getProperties(), and getBody(), developers can dynamically inspect and modify the data flowing through the pipeline. Mastering this API is crucial for building flexible, reusable custom logic that goes beyond the standard capabilities offered by pre-built adapter components.

Exam trap

Candidates often try to access the message body or headers using global variables or incorrect API objects, failing to realize that the 'Message' object is the designated entry point for all context.

184
MCQeasy

An integration developer needs to expose an integration flow in SAP Cloud Integration as an HTTP endpoint that external partners can call using a custom URL path. Which adapter should be used as the sender in the integration flow?

A.IDoc sender adapter
B.SOAP sender adapter
C.HTTPS sender adapter
D.OData V2 sender adapter
AnswerC

The HTTPS sender adapter allows an integration flow to be called via HTTP or HTTPS using a configured address and custom URL path. It supports various HTTP methods and is the standard way to expose an integration flow as an HTTP endpoint for external partners.

Why this answer

The HTTPS sender adapter is designed to expose an integration flow as an HTTP or HTTPS endpoint. It allows configuration of the address and a custom URL path, and it supports multiple HTTP methods, making it the correct choice for external partners to call the integration flow using a custom URL.

Exam trap

The trap here is confusing protocol-specific sender adapters such as SOAP or OData with the generic HTTPS sender adapter that handles arbitrary HTTP requests.

185
MCQmedium

You are designing an integration flow in SAP Cloud Integration that processes incoming XML payloads and must dynamically route messages based on an element value. Which component should you use to evaluate conditions and branch the message flow?

A.Multicast
B.Router
C.Local Integration Process
D.Content Modifier
AnswerB

The Router step evaluates conditions using XPath expressions or exchange properties against the message payload. It directs the message down exactly one matching route or a default path, enabling precise content-based routing logic for diverse incoming requests.

Why this answer

The Router step is specifically designed for content-based routing in SAP Cloud Integration. It evaluates message properties or header values against defined XPath or expression conditions to direct the flow down specific branches, ensuring dynamic processing paths depending on the incoming data payload. This pattern is fundamental when building flexible integration landscapes.

Exam trap

Candidates confuse content-based routing with simple multicast or general filters, incorrectly using filters when they actually need to branch the message flow into multiple alternative paths.

186
MCQmedium

An integration developer is configuring a Message Mapping in SAP Cloud Integration. The target structure requires a single element named TotalPrice that must contain the sum of all Price values present in a repeating source node named Items. Which mapping construct should the developer use to produce this target value?

A.A user-defined function applied in a mapping with context handling over the repeating Price node
B.A Content Modifier that sets TotalPrice as a property using an XPath expression on the payload
C.A value mapping artifact that maps each Price value to a corresponding TotalPrice value
D.A one-to-one mapping from the first Price element to TotalPrice
AnswerA

Summing values from a repeating source node requires a function whose input is evaluated per context and then aggregated. A user-defined function that receives the Price queue as its context can iterate the values and return the arithmetic total, which is then written once to TotalPrice. Standard graphical functions cannot natively sum a repeating node without such context-aware logic, so this is the correct construction.

Why this answer

Producing a single aggregated value from a repeating source node requires mapping logic that evaluates the repeating node as a context and then applies arithmetic across all its occurrences. Standard direct mappings and value mappings are incapable of summation, and Content Modifier operates outside the mapping structure entirely. A user-defined function with the appropriate context handling performs the accumulation and writes the result to the single target element.

Exam trap

The trap here is assuming that any mapping function can automatically iterate a repeating node, when in fact aggregation requires explicit context-aware handling.

187
MCQmedium

You are designing an integration flow in SAP Cloud Integration that processes incoming orders from a partner system. The partner system occasionally sends duplicate order payloads within a short window. You need to implement an idempotent receiver pattern to prevent duplicate processing without writing custom database code. Which step sequence should you configure?

A.Insert a Content Modifier to generate a random UUID, followed by a local integration process containing a Groovy script that queries a Data Store.
B.Place an Idempotent Process Call step referencing a Message ID or custom expression, configured with an appropriate cache duration.
C.Configure a Message Filter step with an XPath expression comparing the current payload hash against the previously stored payload.
D.Add a Router step with a Multi-Cast routing condition to dispatch the payload simultaneously to a normal processing branch and a drop branch.
AnswerB

The Idempotent Process Call step checks incoming message identifiers against a temporary cache repository. If an identifier already exists within the defined time window, the message is automatically filtered out, ensuring robust deduplication with zero custom database maintenance overhead.

Why this answer

Using an Idempotent Process Call step utilizes the tenant's underlying caching infrastructure to track message IDs and discard duplicates natively. This approach is critical in enterprise architectures where duplicate network packets or retries from partner systems can corrupt transactional states and cause business inconsistencies in backend systems.

Exam trap

Candidates often attempt to build custom duplicate checks using Data Store or Variables, failing to realize that the Idempotent Process Call step is the standard, optimized feature for this requirement.

188
MCQhard

An integration developer must design an integration flow that sends a message to a receiver and requires that the message be delivered exactly once, with no duplicates, even if the receiver temporarily acknowledges slowly and the flow is retried. Which quality of service setting should be used on the receiver channel, and what must the receiver provide?

A.Exactly Once with the receiver configured to always return HTTP 200 on the first attempt
B.At Least Once with a unique correlation ID header added by a Content Modifier
C.Best Effort with a retry count of three on the receiver channel
D.Exactly Once with an idempotent receiver that detects and discards duplicate message IDs
AnswerD

Exactly Once quality of service persists the message and, on retry, resends it with the same message ID; the receiving system must therefore implement idempotent processing by recognizing that ID and discarding duplicates. This combination guarantees no duplicate processing even when acknowledgments are slow, which is precisely what the scenario requires.

Why this answer

Exactly Once quality of service ensures the message is persisted and retried with a stable message ID until acknowledged, but it can still resend after a lost acknowledgment, so the receiver must be idempotent and discard messages whose ID it has already processed. Together, persistent delivery and an idempotent receiver produce the required exactly-once effect with no duplicates.

Exam trap

The trap here is assuming that choosing Exactly Once alone eliminates duplicates, when in reality the receiving system must also detect and reject repeated message IDs.

189
MCQeasy

An integration developer needs to expose an integration flow in SAP Cloud Integration so that an external partner can trigger it over HTTPS with a JSON payload, but the partner must not be able to reach any other tenant resource. Which sender adapter configuration is appropriate?

A.An OData sender adapter with OAuth 2.0 and the ESBMessaging.send role assigned to the partner.
B.An IDoc sender adapter with a partner-specific port and principal propagation enabled.
C.An HTTPS sender adapter with a dedicated address and a user role assigned only to the integration flow's runtime artifact.
D.A SOAP sender adapter with WS-Security and a tenant-wide security artifact administrator role.
AnswerC

An HTTPS sender adapter publishes the flow at its own endpoint address, and authorization is enforced through the runtime artifact's role. Granting the partner a role scoped only to that artifact means the credentials can invoke this flow but nothing else, which satisfies the requirement to expose exactly one interface over HTTPS.

Why this answer

Publishing an interface to an external partner requires an HTTPS sender adapter, which exposes the flow at a unique endpoint. Restricting the partner's credentials to a role assigned only to that runtime artifact limits them to invoking this single flow. Alternative adapters either change the protocol away from HTTPS JSON or grant overly broad roles that would expose other tenant resources.

Exam trap

The trap here is equating a valid authentication technology such as OAuth or WS-Security with least-privilege authorization, when the deciding factor is the scope of the role assigned to the partner.

190
MCQhard

An integration developer is troubleshooting a Cloud Integration flow that intermittently fails with a 'Message processing failed: Unable to acquire a connection from the connection pool' error. The flow uses an HTTP receiver adapter to call an external system. The external system is known to have variable response times. Which action should the developer take to resolve this issue?

A.Increase the maximum number of connections in the connection pool for the HTTP receiver adapter
B.Enable the 'Use Keep-Alive' option in the HTTP receiver adapter
C.Increase the connection timeout value in the HTTP receiver adapter
D.Reduce the number of concurrent threads processing messages in the integration flow
AnswerA

The error 'Unable to acquire a connection from the connection pool' means all connections in the pool are in use and the request timed out waiting for one. Increasing the maximum pool size allows more concurrent connections, which can alleviate the exhaustion when the external system has variable response times and holds connections longer. This directly addresses the root cause.

Why this answer

The error indicates that the connection pool has no available connections when a request needs one. This happens when the number of concurrent requests exceeds the pool's maximum size, especially if the external system responds slowly and holds connections. Increasing the maximum pool size directly provides more connections, resolving the exhaustion.

Other options either do not address the pool limit or reduce performance without fixing the root cause.

Exam trap

The trap here is thinking that a longer timeout will solve a pool exhaustion error, when it actually just delays the failure.

191
MCQmedium

An integration developer is configuring a Message Mapping in SAP Cloud Integration to transform an inbound order document. The target structure requires a field named OrderPriority that must be populated with the value HIGH only when the source element OrderAmount exceeds 10000; otherwise MEDIUM. The developer wants the transformation logic to remain reusable and maintainable. Which approach should the developer use?

A.Create an XSLT mapping that hard-codes OrderPriority to HIGH and rely on a router step to select MEDIUM messages.
B.Add a Groovy script step after the mapping that parses the output XML and overwrites OrderPriority.
C.Configure a Content Modifier before the mapping to set OrderPriority as a header, then map the header to the target field.
D.Use a standard function such as ifWithoutElse or a condition expression inside the Message Mapping to assign HIGH or MEDIUM based on OrderAmount.
AnswerD

Message Mapping supports standard functions and condition expressions that can evaluate source values and return different constants, which is exactly the requirement. Implementing the threshold logic directly in the mapping keeps the transformation self-contained, reusable across integration flows, and easy to maintain. It also avoids extra runtime steps and keeps the mapping artifact as the single source of truth for the target structure.

Why this answer

The order value threshold must be evaluated during the structural transformation, and Message Mapping condition expressions with standard functions accomplish that within a single reusable artifact. Keeping the logic in the mapping avoids extra flow steps, prevents duplication of target schema knowledge, and makes the transformation portable across integration flows that need the same priority rule.

Exam trap

The trap here is assuming that any post-mapping script or pre-mapping header assignment can replace conditional logic that belongs inside the Message Mapping itself.

192
MCQhard

You are designing an integration flow in SAP Cloud Integration that must call an external SOAP service. The service requires WS-Security UsernameToken authentication with a password digest. Where do you configure the WS-Security settings so they are applied to the outbound SOAP request?

A.In a Content Modifier step that writes a SOAPAction header before the receiver channel.
B.On the SOAP receiver channel under the WS-Security tab, selecting Username Token and Password Digest.
C.In a Groovy script step that manually builds the entire SOAP envelope including the security header.
D.In the integration flow's runtime configuration artifact under Security Material, creating a User Credentials artifact only.
AnswerB

The SOAP receiver adapter exposes a WS-Security configuration area where you enable Username Token and choose the password digest option. This makes the adapter add the appropriate WS-Security header with a nonce and created timestamp to the outbound request, satisfying the external service's authentication requirement without any custom scripting.

Why this answer

WS-Security UsernameToken with password digest is a native capability of the SOAP receiver adapter. Enabling Username Token and selecting Password Digest on the channel's WS-Security tab causes the adapter to generate the nonce, created timestamp, and digest, and to insert the correct security header into the outbound SOAP request, meeting the external service's authentication requirement.

Exam trap

The trap here is assuming that storing a User Credentials artifact in Security Material is sufficient for WS-Security, when the SOAP channel's WS-Security settings must also be enabled.

193
MCQeasy

An integration developer needs to read a message from an SAP Cloud Integration tenant's JMS queue and forward it to an on-premise SAP S/4HANA system via the Cloud Connector. The developer has already configured the Cloud Connector with the S/4HANA system mapping. Which adapter on the receiver side should be used to reach the on-premise system through the Cloud Connector?

A.HTTP adapter with the virtual host and port configured in the Cloud Connector, and the proxy type set to 'On-Premise'.
B.ProcessDirect adapter with an address matching the Cloud Connector virtual host.
C.IDoc adapter with the Cloud Connector location ID and the on-premise client number.
D.SOAP 1.x adapter with the on-premise host and port specified directly.
AnswerA

The HTTP receiver adapter supports a proxy type of On-Premise, which routes the call through the Cloud Connector tunnel using the virtual host and port defined in the Cloud Connector system mapping. This is the standard way to reach on-premise HTTP endpoints from the tenant. The adapter resolves the virtual address and the Cloud Connector forwards to the physical system, satisfying the connectivity requirement.

Why this answer

On-premise connectivity from SAP Cloud Integration is achieved through the Cloud Connector, which exposes on-premise systems under virtual host and port names. The HTTP receiver adapter includes a Proxy Type setting that, when set to On-Premise, directs the call to the Cloud Connector tunnel. The developer must use the virtual host and port from the Cloud Connector mapping, not the physical address.

Other adapters either target different protocols or stay inside the tenant.

Exam trap

The trap here is using the physical on-premise host and port instead of the virtual host and port defined in the Cloud Connector mapping.

194
MCQmedium

You are configuring a SOAP receiver adapter in SAP Cloud Integration to call a third-party web service. The web service requires WS-Security with a UsernameToken for authentication. Which adapter configuration is necessary?

A.Enable 'WS-Security' and configure the 'Username Token' with the appropriate credentials.
B.Configure the 'Credential' name in the adapter and reference a security artifact.
C.Use OAuth 2.0 client credentials and configure the token endpoint.
D.Set the 'Authentication' method to 'Basic' and enter the username and password.
AnswerA

The SOAP receiver adapter in SAP Cloud Integration supports WS-Security. By enabling WS-Security and selecting the Username Token option, you can provide the username and password. The adapter will then add the WS-Security header to the SOAP request. This is the correct configuration to meet the web service's authentication requirement.

Why this answer

The SOAP receiver adapter must be configured to use WS-Security with a UsernameToken to meet the web service's authentication requirement. This involves enabling WS-Security in the adapter and providing the username and password, either directly or via a security artifact. Other authentication methods like Basic or OAuth operate at different layers and do not satisfy the WS-Security requirement.

Exam trap

The trap here is confusing HTTP-level authentication (Basic, OAuth) with SOAP message-level security (WS-Security), which are distinct and serve different purposes.

195
MCQeasy

An integration developer needs to expose an integration flow as an OData service that external applications can consume. The flow must support query operations with filtering. Which adapter type should be used on the sender side?

A.HTTPS sender adapter
B.SOAP sender adapter
C.OData V2 sender adapter
D.IDoc sender adapter
AnswerC

The OData V2 sender adapter in SAP Cloud Integration is designed to expose an integration flow as an OData service. It automatically handles OData protocol elements such as service metadata, entity sets, and query options including filtering. This allows external applications to consume the flow as a standard OData service without manual implementation of the protocol, directly meeting the scenario requirement.

Why this answer

To expose an integration flow as an OData service, the OData V2 sender adapter is the correct choice. It provides built-in support for OData protocol elements, including metadata documents and query options such as filtering. This enables external applications to consume the flow using standard OData clients without custom protocol handling, which is exactly what the scenario requires.

Exam trap

The trap here is assuming that any HTTP-based adapter can serve OData, when only the dedicated OData adapter provides the required protocol semantics like metadata and filtering.

196
MCQhard

An integration developer is configuring a Message Mapping step in SAP Cloud Integration. The source message contains a repeating node with multiple occurrences of an employee ID and name. The target structure requires a single concatenated string of all employee names separated by commas. Which mapping function should the developer use to achieve this?

A.Use the 'join' function with a comma as the delimiter on the repeating node.
B.Use the 'substring' function to extract each name and then combine them.
C.Use the 'concat' function to combine the employee names directly.
D.Use the 'split' function to break the repeating node into individual strings and then reassemble.
AnswerA

The 'join' function in SAP Cloud Integration's message mapping takes a context (repeating node) and concatenates its values into a single string using a specified delimiter. Applying it to the employee name node with a comma delimiter produces the required comma-separated list of all employee names, satisfying the target structure.

Why this answer

To concatenate multiple occurrences of a repeating node into a single delimited string, the 'join' function is designed for this purpose. It takes a context and a delimiter, producing a single string with all values separated by the delimiter. Other functions like 'concat', 'split', or 'substring' do not perform this aggregation on repeating nodes, making 'join' the correct choice.

Exam trap

The trap here is assuming that 'concat' can combine values from a repeating node, when it only works on individual strings, leading to an incorrect mapping that fails to aggregate all occurrences.

197
Multi-Selectmedium

An integration developer is troubleshooting an integration flow that intermittently fails when calling an external REST API. The API returns HTTP 429 Too Many Requests during peak loads. The developer wants to make the flow more resilient without changing the external API. Which TWO actions should the developer take? (Choose two.)

Select 2 answers
A.Switch the receiver adapter from HTTPS to HTTP to bypass rate limiting.
B.Implement a throttling mechanism in the integration flow to limit the number of outbound calls per time interval.
C.Configure the receiver adapter's retry settings to retry on HTTP 429 with an exponential backoff.
D.Increase the JVM heap size of the tenant to handle more concurrent requests.
E.Disable the CSRF protection on the sender adapter to reduce processing overhead.
AnswersB, C

Throttling the outbound calls reduces the request rate to the external API, keeping it within the allowed limits and preventing HTTP 429 responses. SAP Cloud Integration offers throttling capabilities that can be applied to control call frequency. This is a direct and effective way to make the flow resilient against rate limiting without requiring changes to the external API.

Why this answer

HTTP 429 responses indicate the external API is rate limiting the caller. The effective remedies are to retry with exponential backoff, which spaces attempts and respects the API's recovery time, and to throttle outbound calls so the flow stays within the allowed request rate. Together these actions reduce 429 occurrences without modifying the external API, addressing the root cause of the intermittent failures.

Exam trap

The trap here is treating HTTP 429 as a capacity or security problem, when it is actually a rate-limiting signal that must be handled with retry/backoff and throttling rather than heap or protocol changes.

198
MCQmedium

An integration developer is configuring a timer-initiated integration flow that must run every day at 02:00 UTC and process data from an SFTP server. The developer sets the Timer start event to 'Schedule to Recur' with a cron expression. Which cron expression correctly schedules the flow to run daily at 02:00 UTC?

A.0 0 0 2 * ?
B.2 0 0 * * ?
C.0 2 0 * * ?
D.0 0 2 * * ?
AnswerD

In SAP Cloud Integration, the Timer start event uses a Quartz-style cron expression with six fields: seconds, minutes, hours, day of month, month, and day of week. The expression 0 0 2 * * ? means second 0, minute 0, hour 2, every day of month, every month, and no specific day of week. This correctly schedules the flow daily at 02:00.

Why this answer

The Timer start event in SAP Cloud Integration uses a six-field Quartz cron expression ordered as seconds, minutes, hours, day of month, month, and day of week. To run daily at 02:00, the seconds and minutes fields must be 0, the hours field must be 2, and the day and month fields must be wildcards, with a question mark for day of week. The expression 0 0 2 * * ? matches this exactly.

Exam trap

The trap here is misordering the cron fields, since many developers are used to five-field cron where minutes come first, but SAP Cloud Integration uses a six-field Quartz format starting with seconds.

199
MCQmedium

An integration developer is building an integration flow in SAP Cloud Integration that must send a message to a receiver system using the SOAP 1.x adapter with WS-Security UsernameToken authentication. The security team requires that the password not be transmitted in plain text, and that the nonce and timestamp be included in the SOAP header. Which configuration should the developer apply on the SOAP receiver channel?

A.Enable Transport Binding with HTTPS and leave the WS-Security UsernameToken at default settings.
B.Configure the SOAP adapter to use X.509 Token and sign the message body with the tenant's keystore entry.
C.Set Security Mode to Username Token and select 'Password Text' while adding a WS-Policy assertion for nonce.
D.Set Security Mode to Username Token and enable 'Password Digest' with nonce and timestamp.
AnswerD

The SOAP 1.x adapter's WS-Security UsernameToken with Password Digest hashes the password together with a generated nonce and a creation timestamp, so the cleartext secret never crosses the wire. Enabling nonce and timestamp also satisfies the replay-protection requirement the security team stated. This is the standard out-of-the-box configuration for this scenario and requires no custom scripting.

Why this answer

The SOAP 1.x receiver adapter supports WS-Security UsernameToken with two password modes. Password Digest hashes the password with a nonce and timestamp, ensuring the cleartext credential never appears in the SOAP header, while also providing replay protection. Password Text would expose the credential, and transport-level or certificate-based options do not satisfy the receiver's UsernameToken expectation.

Configuring Password Digest plus nonce and timestamp meets all stated requirements.

Exam trap

The trap here is assuming that enabling HTTPS on the SOAP channel automatically secures the WS-Security UsernameToken, when transport encryption and token serialization are independent concerns.

200
Multi-Selectmedium

An integration developer is designing a Cloud Integration flow that must call an external REST API. The API requires a bearer token that expires every 30 minutes, and the flow is invoked frequently. The developer wants to avoid requesting a new token on every call. Which TWO measures should the developer implement? (Choose two.)

Select 2 answers
A.Disable token expiry validation on the external API by requesting a token with an infinite lifetime.
B.Configure the OAuth2 client credentials grant with a token cache enabled on the adapter so tokens are reused across calls.
C.Store the token in a data store and reuse it until its expiry time, refreshing only when it is close to expiration.
D.Call the token endpoint before every API request to guarantee a fresh token.
E.Hard-code the bearer token in the integration flow configuration and update it manually before each expiry.
AnswersB, C

The OAuth2 client credentials grant on the HTTP receiver adapter includes a token cache that automatically reuses valid tokens and refreshes them when they expire. Enabling this cache eliminates a token request per call without custom logic. It is the built-in mechanism for exactly this scenario and works with the 30-minute expiry by refreshing before the token becomes invalid.

Why this answer

To avoid requesting a token on every call, the developer should cache the token and reuse it until expiry. This can be done either by storing the token in a data store and refreshing near expiration, or by enabling the OAuth2 client credentials token cache on the adapter, which handles reuse and refresh automatically. Hard-coding, requesting infinite lifetime, or fetching a token per call all fail the efficiency and security requirements.

Exam trap

The trap here is thinking that a fresh token must be requested for each call to be safe, when caching a valid token until near expiry is both secure and efficient.

201
MCQmedium

An integration developer is configuring a Process Integration scenario in SAP Cloud Integration that uses a SOAP receiver adapter to call an external web service. The web service requires WS-Security with a UsernameToken for authentication. The developer has configured the SOAP adapter with the appropriate security settings. However, during testing, the external service returns a '401 Unauthorized' error. The developer verifies that the username and password are correct. What is the most likely cause?

A.The WS-Security policy requires the password to be sent as plain text, but the adapter is configured to send it as a digest.
B.The external service requires the UsernameToken to be signed, but the adapter is only configured to encrypt it.
C.The SOAP adapter is missing a keystore entry for the external service's certificate.
D.The SOAP adapter does not support WS-Security UsernameToken; it only supports Basic Authentication.
AnswerA

WS-Security UsernameToken can be configured with different password types: PasswordText or PasswordDigest. If the external service expects PasswordText but the adapter sends PasswordDigest, authentication fails with a 401. The developer must align the password type setting with the service's requirements to resolve the error.

Why this answer

WS-Security UsernameToken supports two password types: PasswordText and PasswordDigest. If the external service expects one type but the adapter sends the other, authentication fails with a 401 Unauthorized. The developer must check the service's WS-Security policy and configure the SOAP adapter's password type accordingly to match the expected format.

Exam trap

The trap here is assuming that correct username and password are sufficient, overlooking the password type (text vs. digest) required by WS-Security.

202
MCQeasy

An integration developer needs to expose a SOAP-based web service from SAP Cloud Integration. The service must validate incoming messages against an XSD schema and reject invalid messages with a SOAP fault. Which step should be used in the integration flow to perform the validation?

A.XML Validator step
B.Schema Validation step
C.XSD Check step
D.Message Mapping step with XSD validation
AnswerA

The XML Validator step in SAP Cloud Integration validates an XML payload against an XSD schema. If the message is invalid, it throws an exception that can be caught and transformed into a SOAP fault using an Exception Subprocess. This step is specifically designed for schema validation and is the correct choice for enforcing message structure in a SOAP service.

Why this answer

The XML Validator step is specifically designed to validate XML payloads against an XSD schema. When validation fails, it raises an exception that can be handled in an Exception Subprocess to return a SOAP fault. This ensures that only messages conforming to the defined schema are processed, meeting the requirement to reject invalid messages with a proper SOAP fault.

Exam trap

The trap here is confusing the XML Validator step with other transformation or mapping steps that do not perform schema validation.

203
MCQmedium

An integration developer needs to connect SAP Integration Suite to an enterprise database using the JDBC Adapter. The requirement is to execute a stored procedure that accepts multiple input parameters and returns a result set containing a list of updated records. How should the developer configure the integration flow and JDBC adapter?

A.Select the 'Stored Procedure' operation in the JDBC receiver adapter and map the payload using a custom XML structure matching the procedure signature.
B.Use a Content Modifier step to construct a raw SQL 'EXECUTE' command string and send it via the OData V2 adapter.
C.Configure the JDBC adapter as a sender channel with a polling interval of zero seconds to trigger real-time stored procedure execution.
D.Wrap the database call inside a JMS Message Queue step that automatically converts XML payloads into SQL statements.
AnswerA

Selecting the Stored Procedure operation in the JDBC adapter instructs the runtime to invoke database routines correctly. Providing an XML payload structure that aligns with the expected parameter definitions ensures that input arguments pass successfully to the backend database.

Why this answer

Configuring the JDBC adapter for stored procedure execution requires selecting the appropriate operation type, structuring the payload to match expected parameter definitions, and handling the returned SQL result set correctly. Proper parameter mapping ensures that SQL execution succeeds without syntax or type mismatch errors.

Exam trap

Candidates often try to use standard SQL statements instead of the specific Stored Procedure operation, failing to realize the adapter requires a distinct XML structure to map input parameters correctly.

204
MCQeasy

An integration developer needs to expose a SOAP-based web service from SAP Cloud Integration. The service must accept a synchronous request, transform the payload using a message mapping, and return a response. Which adapter type should be used on the sender side to receive the SOAP request?

A.IDoc sender adapter
B.HTTPS sender adapter
C.OData sender adapter
D.SOAP sender adapter
AnswerD

The SOAP sender adapter in SAP Cloud Integration is specifically designed to receive SOAP requests over HTTP or HTTPS. It supports WS-Security and can handle synchronous request-response patterns. Using it allows the integration flow to be exposed as a SOAP web service, which is exactly what the scenario requires for accepting and responding to SOAP calls.

Why this answer

To expose a SOAP web service from SAP Cloud Integration, the SOAP sender adapter is the appropriate choice. It natively handles SOAP envelopes, supports synchronous request-response, and provides WS-Security options. Other adapters like HTTPS or OData do not understand SOAP and would require custom parsing.

Exam trap

The trap here is assuming that any HTTP-based adapter can handle SOAP, but only the SOAP sender adapter provides built-in SOAP protocol support and security.

205
MCQeasy

An integration developer needs to store a value from an incoming message so that it can be used later in the same integration flow, after several mapping steps that change the body. The value is a simple string extracted from a header. Which artifact should be used to persist this value across steps?

A.An exchange property set with a Content Modifier or script
B.A variable defined in the integration flow model
C.A message header created by a Groovy script
D.A data store entry written with the Data Store operation
AnswerA

Exchange properties are stored in the message exchange and are not affected by body transformations. They persist for the duration of the integration flow and can be read by later steps, including mappings and scripts. Using a Content Modifier or Groovy script to set a property ensures the value remains available even after the body is replaced multiple times.

Why this answer

Exchange properties live in the message exchange and survive body transformations, making them the right choice for a value that must be available later in the same integration flow. Headers can be altered or dropped, data stores are for persistence of messages, and there is no general modeled variable for runtime values, so a property set by a Content Modifier or script is the correct artifact.

Exam trap

The trap here is confusing headers with properties, since both can hold values, but only properties are reliably preserved when the message body is rebuilt by mappings.

206
MCQhard

An integration developer must ensure that a Cloud Integration flow processes messages from a JMS queue exactly once, even when the tenant restarts mid-processing. The flow currently uses a JMS sender adapter with default settings and occasionally reprocesses messages after a restart. What should the developer configure to prevent duplicate processing?

A.Set the JMS queue to use a short expiration time so stale messages are discarded before they can be reprocessed.
B.Enable transactional handling on the JMS sender adapter so the message is acknowledged only after the integration flow completes successfully.
C.Configure a Message Filter step that checks a custom header and drops messages that were already seen.
D.Increase the maximum number of concurrent consumers on the JMS sender adapter to spread the load across threads.
AnswerB

Transactional handling defers the JMS acknowledgement until the flow finishes, so a restart before completion leaves the message unacknowledged and available for redelivery without data loss. Once the flow commits, the acknowledgement is sent and the message is removed. This is the standard mechanism that prevents both message loss and duplicate processing across restarts in Cloud Integration.

Why this answer

Exactly-once behavior across restarts depends on deferring the JMS acknowledgement until the integration flow has completed. Transactional handling on the JMS sender adapter provides this by acknowledging only after successful processing, so a restart mid-flow leaves the message available for redelivery. Expiration, concurrency, and custom header filters do not bind acknowledgement to flow completion and therefore cannot prevent duplicate processing.

Exam trap

The trap here is believing that higher concurrency or a deduplication filter prevents reprocessing, when only transactional acknowledgement ties message removal to successful flow completion.

207
MCQhard

An integration developer is configuring an integration flow that must process messages from a JMS queue in SAP Cloud Integration. The queue is defined with a message retention period of 7 days and a maximum message size of 10 MB. The developer needs to ensure that messages are not lost if the integration flow fails during processing. Which JMS transaction mode should be used?

A.None
B.Auto-commit
C.Client-acknowledged
D.Transacted
AnswerD

Transacted mode in SAP Cloud Integration JMS adapter ensures that the message is only acknowledged (committed) after the integration flow completes successfully. If the flow fails, the transaction is rolled back and the message remains in the queue for redelivery. This provides exactly-once or at-least-once delivery semantics, preventing message loss. It is the correct choice when messages must not be lost on processing failure.

Why this answer

Transacted mode is the only JMS transaction mode in SAP Cloud Integration that guarantees a message is not removed from the queue until the integration flow successfully completes. If processing fails, the transaction rolls back and the message is redelivered, preventing loss. The other modes either commit immediately upon reading or provide no transactional guarantees.

Exam trap

The trap here is confusing auto-commit with transacted mode, assuming that auto-commit ensures reliability because it is the default.

208
MCQeasy

An integration developer must expose an integration flow so that an external partner can call it using a simple HTTPS request and receive a synchronous JSON response. The partner cannot handle SOAP or OData. Which adapter should be configured as the sender in the integration flow?

A.IDoc sender adapter
B.SOAP 1.x sender adapter
C.OData V2 sender adapter
D.HTTPS sender adapter
AnswerD

The HTTPS sender adapter exposes the integration flow as a plain HTTP endpoint that accepts any payload, including JSON, and returns the response synchronously. It requires no SOAP envelope or OData conventions, so it matches the partner's capability and the synchronous JSON requirement precisely.

Why this answer

The HTTPS sender adapter is the correct choice because it exposes a generic HTTP endpoint that accepts arbitrary payloads such as JSON and supports synchronous request-response processing. SOAP, OData, and IDoc adapters all impose protocol-specific payload structures that the partner explicitly cannot support.

Exam trap

The trap here is assuming any HTTP-capable adapter works, when SOAP and OData adapters enforce protocol-specific payloads that would break a plain JSON client.

209
Multi-Selecthard

An integration developer is configuring an integration flow that must call an external SOAP service over HTTPS. The service requires WS-Security UsernameToken authentication and the developer must also validate the service's certificate. Which TWO actions should the developer perform in SAP Cloud Integration? (Choose two.)

Select 2 answers
A.Add a Content Modifier to insert the UsernameToken header manually into the SOAP envelope
B.Configure a WS-Security Username Token in the SOAP receiver adapter with a User Credentials artifact
C.Enable OAuth 2.0 client credentials in the SOAP adapter's authentication settings
D.Deploy the service's root CA certificate in the tenant keystore and reference it in the SOAP adapter's trust configuration
E.Configure the SOAP adapter to use Proxy Type 'On-Premise' with a Cloud Connector location ID
AnswersB, D

The SOAP receiver adapter supports WS-Security UsernameToken configuration, where the username and password are sourced from a deployed User Credentials artifact. This satisfies the service's authentication requirement without hardcoding secrets. It is the standard mechanism for UsernameToken in Cloud Integration and directly addresses the scenario.

Why this answer

WS-Security UsernameToken is configured in the SOAP receiver adapter using a User Credentials artifact, and validating the service's certificate requires the issuing CA in the tenant keystore. Together these satisfy both authentication and trust requirements. OAuth, manual header insertion, and on-premise proxy settings do not meet the stated needs.

Exam trap

The trap here is treating WS-Security UsernameToken as interchangeable with OAuth or manual header injection, when only the SOAP adapter's built-in WS-Security configuration properly generates the token.

210
MCQeasy

You are creating an integration flow that must convert an incoming XML payload to JSON. The XML contains attributes that you want to preserve as JSON properties. Which step should you use?

A.Content Modifier
B.Groovy Script
C.XML to JSON Converter
D.Message Mapping
AnswerC

The XML to JSON Converter step is specifically designed to transform XML payloads into JSON format. It automatically handles XML attributes by converting them into JSON properties, typically prefixed with '@' or as specified in the converter settings. This step is the standard and most efficient way to achieve the required conversion in SAP Cloud Integration.

Why this answer

The XML to JSON Converter step is purpose-built for converting XML to JSON and automatically handles attributes by mapping them to JSON properties. Other steps like Message Mapping or Groovy Script can achieve similar results but require additional effort and configuration. The converter is the simplest and most reliable choice for this scenario.

Exam trap

The trap here is thinking that a Message Mapping or Groovy Script is needed for XML-to-JSON conversion, when the dedicated converter step is the correct and simplest solution.

211
MCQmedium

An integration developer is building an integration flow that must call an external REST API protected by OAuth 2.0 client credentials. The API requires the client ID and client secret to be sent as HTTP Basic authentication to the token endpoint, and the resulting access token must be attached as a Bearer token to every subsequent request. The developer wants to avoid hardcoding the credentials in the integration flow and wants the token to be reused across multiple message exchanges until it expires. Which approach should the developer use?

A.Store the client ID and client secret in a Partner Directory parameter and read them with a Groovy script that performs the token request on every message.
B.Configure the HTTP receiver adapter with OAuth 2.0 Client Credentials authentication and use a Keystore Monitor entry containing the client ID and client secret.
C.Configure the HTTP receiver adapter with OAuth 2.0 Client Credentials authentication and select a Security Material of type OAuth2 Client Credentials that stores the client ID, client secret, and token service URL.
D.Create a User Credentials security material containing the client ID and client secret, then reference it from the HTTP receiver adapter using Basic authentication.
AnswerC

The OAuth2 Client Credentials security material stores the client ID, client secret, and token service URL, and the HTTP receiver adapter automatically requests, caches, and refreshes the access token. This avoids hardcoding credentials in the flow and reuses the token until it expires, which matches the requirement exactly.

Why this answer

OAuth 2.0 client credentials flows require a security material that holds the client ID, client secret, and token service URL. SAP Cloud Integration provides the OAuth2 Client Credentials artifact type for exactly this purpose, and the HTTP receiver adapter uses it to fetch and cache the access token. This removes hardcoded secrets and avoids per-message token requests.

Exam trap

The trap here is assuming any security material that stores a secret can be used for OAuth 2.0, when only the OAuth2 Client Credentials artifact type supports the token endpoint flow.

212
MCQmedium

An integration developer is configuring a Message Mapping in SAP Cloud Integration. The target structure requires that for each Order element in the source, a corresponding OrderConfirmation element is created, but only when the Order/Status field equals 'APPROVED'. Which mapping technique should the developer use to achieve this conditional one-to-many transformation?

A.Use a one-to-many mapping with a context change and a condition check on the Status field before creating the target element.
B.Use a many-to-one mapping with a join function to merge all Orders into a single OrderConfirmation.
C.Use a value mapping to translate the Status field to a boolean and then use a standard mapping to create the target element.
D.Use a one-to-one mapping with a standard function and rely on the target structure to filter out unwanted elements.
AnswerA

A one-to-many mapping allows you to create multiple target elements from a single source context. By changing the context to the Order node and applying a condition (e.g., using the 'if' or 'equals' function) on the Status field, you can ensure that an OrderConfirmation is only generated when Status equals 'APPROVED'. This is the standard approach for conditional one-to-many transformations in SAP Cloud Integration Message Mapping.

Why this answer

The requirement is to conditionally create one target element per source element based on a field value. In SAP Cloud Integration Message Mapping, this is achieved with a one-to-many mapping combined with a context change to the source node and a condition check. The context change ensures the mapping operates per Order, and the condition (e.g., using the 'if' function) ensures only approved Orders produce an OrderConfirmation.

Other mapping types do not support conditional element creation.

Exam trap

The trap here is confusing value mapping or standard functions with the ability to conditionally control target element cardinality, which actually requires a one-to-many mapping with a context change and a condition.

213
MCQmedium

An integration developer is building a flow that receives an XML order and must transform it to JSON for a downstream REST API. The XML contains an attribute on the root element that must appear as a JSON property named 'orderId'. The developer uses the XML-to-JSON converter but the attribute is missing from the output. What is the most appropriate action?

A.Enable the 'Convert Attributes' option in the XML-to-JSON converter so XML attributes are emitted as JSON properties.
B.Set the converter's namespace handling to 'Ignore Namespaces' so attributes are treated as elements.
C.Add a Message Mapping step before the converter to move the attribute into a child element.
D.Replace the XML-to-JSON converter with a JSON-to-XML converter and reverse the flow direction.
AnswerA

By default the XML-to-JSON converter ignores attributes unless attribute conversion is enabled. Turning on the convert attributes option emits each attribute as a JSON property, so the root attribute appears as 'orderId'. This is the direct configuration change that addresses the missing attribute without altering the source XML or adding mapping logic.

Why this answer

The XML-to-JSON converter omits attributes unless attribute conversion is explicitly enabled. Enabling the convert attributes option causes each attribute to be emitted as a JSON property, which places the root attribute into the output as 'orderId'. Remapping the attribute into an element, using the wrong converter direction, or adjusting namespace handling do not address the underlying configuration that controls attribute emission.

Exam trap

The trap here is assuming the converter always includes attributes, when by default it drops them unless attribute conversion is explicitly turned on.

214
MCQmedium

You are troubleshooting an integration flow that uses a Request Reply step to call an external REST API. The API returns a JSON response, but the subsequent mapping step fails because the message body is not recognized as JSON. The integration flow has a Content Modifier step before the Request Reply that sets the header 'Content-Type' to 'application/json'. What is the most likely cause of the issue?

A.The Content Modifier sets the header on the request, but the response's Content-Type header is not being propagated or is being overwritten.
B.The mapping step requires the message body to be converted to XML before processing JSON.
C.The Request Reply step does not support JSON responses and only handles XML.
D.The Content Modifier step must also set the 'Accept' header to 'application/json' to receive a JSON response.
AnswerA

The Content Modifier sets the 'Content-Type' header for the outbound request, but the response from the REST API may have its own Content-Type header. If the integration flow does not preserve or correctly handle the response header, the mapping step might see a different or missing Content-Type, causing it to not parse the body as JSON. This is a common issue when the response headers are not explicitly managed.

Why this answer

The most likely cause is that the response's Content-Type header is not being correctly propagated or is being overwritten. The Content Modifier sets the request header, but the response headers are separate. If the response lacks a proper Content-Type or it is altered, the mapping step may not parse the body as JSON.

Ensuring the response's Content-Type is preserved or explicitly set to application/json before mapping resolves the issue.

Exam trap

The trap here is assuming that setting the request's Content-Type header also affects the response, when in fact response headers are independent and must be handled separately.

215
MCQeasy

You are designing an integration flow that must split an incoming XML message containing multiple order items into individual messages, process each item separately, and then aggregate the results into a single response. Which pair of flow steps should you use to achieve this?

A.Content Modifier and Message Mapping
B.Router and Multicast
C.Iterating Splitter and Join
D.Splitter and Gather
AnswerD

The Splitter step divides a message into multiple messages based on an XPath expression, and the Gather step collects these messages back into a single message. This combination is the standard pattern for processing individual items and then aggregating the results into one response, exactly as required.

Why this answer

To process each order item separately and then combine the results, the integration flow must split the incoming message into multiple messages, process them, and then gather them back. The Splitter step performs the split, and the Gather step performs the aggregation. Other steps like Router, Multicast, or Content Modifier do not change message cardinality in the required way.

Exam trap

The trap here is confusing steps that route or copy messages with steps that actually split and recombine message cardinality, leading to selection of Multicast or Router instead of Splitter and Gather.

216
MCQhard

An integration developer must split a large XML payload into individual messages and process them in parallel, but the order of the resulting records in the target system does not matter. The developer wants the split messages to be handled concurrently rather than sequentially. Which configuration on the Splitter step should the developer use?

A.Set the Splitter to sequential processing and rely on the Parallel Multicast step instead
B.Set the Splitter to sequential processing and add a Gather step after it
C.Set the Splitter to sequential processing and increase the tenant's worker node count
D.Set the Splitter's processing mode to Parallel Processing on the split elements
AnswerD

The Splitter step supports a parallel processing mode that distributes the split messages to multiple worker threads. Because the target does not require ordering, parallel processing is appropriate and yields higher throughput, while the Splitter still emits one message per repeating element as required.

Why this answer

When split records are independent and ordering is irrelevant, the Splitter's parallel processing mode is the correct lever. It emits one message per repeating element and hands those messages to multiple threads, raising throughput. Sequential mode, multicast, extra worker nodes, or a Gather step do not introduce the required element-level concurrency.

Exam trap

The trap here is confusing the Parallel Multicast step, which fans out copies of one message, with the Splitter's parallel processing mode, which fans out the split elements themselves.

217
MCQhard

An integration developer is using a Groovy script in SAP Cloud Integration to parse a large XML payload. The script uses XmlSlurper to navigate the XML. During testing, the developer notices that the script consumes excessive memory and sometimes throws OutOfMemoryError. Which approach should be taken to mitigate this issue?

A.Increase the script's memory allocation by setting the 'scriptMemory' parameter in the integration flow.
B.Replace XmlSlurper with XmlParser to improve memory efficiency.
C.Use a streaming approach with StAX (Streaming API for XML) to parse the XML incrementally.
D.Convert the XML to JSON using a Message Mapping step before processing in Groovy.
AnswerC

StAX parses XML in a streaming fashion, reading and processing elements as they are encountered without loading the entire document into memory. This significantly reduces memory usage and is ideal for large XML payloads, preventing OutOfMemoryError.

Why this answer

For large XML payloads, using a streaming parser like StAX is the most memory-efficient approach. StAX reads the XML sequentially, allowing the script to process elements on the fly without building an in-memory tree, thus avoiding OutOfMemoryError.

Exam trap

The trap here is thinking that switching between XmlSlurper and XmlParser solves memory issues; both are DOM-based and load the entire document into memory.

218
Multi-Selecthard

You are configuring an integration flow that connects to an external OData V4 service using the OData adapter in SAP Cloud Integration. Which TWO configurations are mandatory when defining the OData V4 receiver adapter connection parameters? Choose TWO correct answers.

Select 2 answers
A.Address (URL)
B.Proxy Type
C.Authentication
D.EDMX File Repository Path
E.Batch Processing Chunk Size
AnswersA, C

The target service URL is mandatory because the adapter needs to know the exact endpoint address where the OData V4 requests must be sent. Without this specific URI, the runtime cannot route outbound payloads to the intended external destination.

Why this answer

Configuring the OData V4 adapter requires specifying both the correct target service URL and selecting an appropriate authentication method to secure outbound communication. These two parameters form the baseline contract required by the runtime to establish a valid secure connection to the remote SAP or third-party service endpoint.

Exam trap

Candidates often mistakenly include 'Proxy Type' or 'Timeout' as mandatory configuration fields, confusing standard connectivity parameters with the essential baseline requirements needed to establish a successful handshake with the OData service.

Page 2

Page 3 of 3

All pages

Practice C_CPI by domain

Target a specific domain to shore up weak areas.

See all domains with question counts →