Cisco CCNP 350-401 ENCOR Python, JSON, YANG, Catalyst Center/SD-WAN APIs, and REST Results Practice Test 3

Topic 19 Practice Test 3 covers Python, JSON, YANG, Catalyst Center/SD-WAN APIs, and REST Results for Cisco 350-401 ENCOR. For broader exam preparation, review the Cisco 350-401 ENCOR Exam Dumps. Every option includes focused technical reasoning explaining both the Cisco enterprise networking concept and its fit to the scenario.

Question 1

A Cisco network automation engineer is evaluating a design that must avoid manual string splitting when consuming structured JSON text. No broader redesign is requested. Which mechanism should the architect select? Choose ONE.

Explicit HTTP timeout
HTTP POST
json.dumps()
json.loads()

Correct Answer(s)

Rationale

Explicit HTTP timeout can be appropriate to prevent a Python network automation job from hanging indefinitely on an unresponsive controller. It bounds how long an automation request waits. The stated constraint is to avoid manual string splitting when consuming structured JSON text; so the required behavior is still absent.
HTTP POST solves scenarios that need to request a token from an authentication endpoint that specifies POST. It submits data to create or invoke an operation. The design decision here is to avoid manual string splitting when consuming structured JSON text; so it misses the requirement here.
json.dumps() is intended to control machine-readable JSON serialization instead of using Python’s repr output. It serializes Python objects into a JSON string. The stem instead requires the team to avoid manual string splitting when consuming structured JSON text; which leaves this requirement unresolved.
json.loads() is the best fit because it parses a JSON string into Python objects. The case requires the team to avoid manual string splitting when consuming structured JSON text. That is the requested behavior here.

Question 2

A Cisco network automation engineer is correcting an implementation so it can control machine-readable JSON serialization instead of using Python’s repr output. Unrelated availability and identity settings must not change. What is the most appropriate implementation? Choose ONE.

Exponential backoff retry
HTTP PUT
json.dumps()
response.json()

Correct Answer(s)

Rationale

Exponential backoff retry normally helps teams recover from HTTP 429 without hammering the controller repeatedly. It spaces retries after transient throttling or server errors. The actual requirement is to control machine-readable JSON serialization instead of using Python’s repr output; so it misses the requirement here.
HTTP PUT is useful when teams need to repeat the same full-resource update without creating additional objects. It replaces a resource representation idempotently. Here the need is to control machine-readable JSON serialization instead of using Python’s repr output; which leaves this requirement unresolved.
json.dumps() is the best fit because it serializes Python objects into a JSON string. The case requires the team to control machine-readable JSON serialization instead of using Python’s repr output. That property directly matches the constraint.
response.json() belongs where the goal is to read a Catalyst Center response body as Python data after a successful request. It decodes JSON directly from an HTTP response. This case instead needs control machine-readable JSON serialization instead of using Python’s repr output; so it does not meet this constraint.

Question 3

A Cisco network automation engineer has been asked to extract keys from a REST response whose media type is JSON. The change should be limited to the relevant layer. Which option solves the requirement at the correct layer? Choose ONE.

response.json()
Refresh the API token after HTTP 401
HTTP PATCH
response.raise_for_status()

Correct Answer(s)

Rationale

response.json() is the best fit because it decodes JSON directly from an HTTP response. The case requires the team to extract keys from a REST response whose media type is JSON. That property directly matches the constraint.
Refresh the API token after HTTP 401 serves designs that must distinguish an authentication failure from a missing-resource response. It handles expired or invalid authentication. But this case needs the team to extract keys from a REST response whose media type is JSON; rather than the decision posed here.
HTTP PATCH can be appropriate to preserve unspecified resource fields while applying a targeted update. It applies a partial resource update. The stated constraint is to extract keys from a REST response whose media type is JSON; so it does not meet this constraint.
response.raise_for_status() solves scenarios that need to fail fast when a Python requests call returns a 4xx or 5xx status. It raises exceptions for unsuccessful HTTP responses. The design decision here is to extract keys from a REST response whose media type is JSON; which is a different design problem.

Question 4

A Cisco network automation engineer needs a solution that can route HTTP failures into exception handling without manually testing every status code. Only this stated constraint is driving the decision. What should the team use? Choose ONE.

response.raise_for_status()
Correct authorization or role after HTTP 403
HTTP DELETE
Explicit HTTP timeout

Correct Answer(s)

Rationale

response.raise_for_status() is the best fit because it raises exceptions for unsuccessful HTTP responses. The case requires the team to route HTTP failures into exception handling without manually testing every status code. This addresses the requirement at the intended layer.
Correct authorization or role after HTTP 403 is intended to separate authorization policy failure from token-expiration handling. It addresses authenticated-but-forbidden access. The stem instead requires the team to route HTTP failures into exception handling without manually testing every status code; so it does not meet this constraint.
HTTP DELETE normally helps teams remove YANG-modeled data through a RESTCONF endpoint that supports DELETE. It removes the addressed REST resource. The actual requirement is to route HTTP failures into exception handling without manually testing every status code; which is a different design problem.
Explicit HTTP timeout is useful when teams need to prevent a Python network automation job from hanging indefinitely on an unresponsive controller. It bounds how long an automation request waits. Here the need is to route HTTP failures into exception handling without manually testing every status code; and therefore is not the best fit.

Question 5

A Cisco network automation engineer must choose a mechanism to return control to retry logic when the API stops responding. The team wants the most specific native mechanism. Which approach addresses the stated constraint? Choose ONE.

Correct the URI or identifier after HTTP 404
Content-Type header
Explicit HTTP timeout
Exponential backoff retry

Correct Answer(s)

Rationale

Correct the URI or identifier after HTTP 404 is useful when teams need to fix a request that targets a nonexistent object ID. It addresses a missing API resource. Here the need is to return control to retry logic when the API stops responding; so it does not meet this constraint.
Content-Type header addresses cases that need to fix a request rejected because the server cannot interpret the submitted body format. It describes the media type of the request body. For this question the team must return control to retry logic when the API stops responding; which is a different design problem.
Explicit HTTP timeout is the best fit because it bounds how long an automation request waits. The case requires the team to return control to retry logic when the API stops responding. The scenario depends on exactly that capability.
Exponential backoff retry serves designs that must recover from HTTP 429 without hammering the controller repeatedly. It spaces retries after transient throttling or server errors. But this case needs the team to return control to retry logic when the API stops responding; leaving the stated need unsatisfied.

Question 6

A Cisco network automation engineer has this requirement: make large automation jobs resilient to short-lived API saturation. The implementation should not expand scope beyond this need. Which option is the best fit? Choose ONE.

Conflict-aware handling for HTTP 409
Exponential backoff retry
Accept header
Refresh the API token after HTTP 401

Correct Answer(s)

Rationale

Conflict-aware handling for HTTP 409 serves designs that must resolve a create or update that conflicts with existing controller state. It addresses a resource state conflict. But this case needs the team to make large automation jobs resilient to short-lived API saturation; which is a different design problem.
Exponential backoff retry is the best fit because it spaces retries after transient throttling or server errors. The case requires the team to make large automation jobs resilient to short-lived API saturation. That is the requested behavior here.
Accept header solves scenarios that need to separate response-content negotiation from the encoding of the request body. It requests a preferred response representation. The design decision here is to make large automation jobs resilient to short-lived API saturation; leaving the stated need unsatisfied.
Refresh the API token after HTTP 401 is intended to recover when Catalyst Center reports unauthorized because its token has expired. It handles expired or invalid authentication. The stem instead requires the team to make large automation jobs resilient to short-lived API saturation; so the required behavior is still absent.

Question 7

A Cisco network automation engineer is reviewing how to request a fresh token before repeating a call rejected as unauthenticated. The selected control should solve this condition directly. Which choice most directly meets the requirement? Choose ONE.

HTTP GET
Refresh the API token after HTTP 401
Catalyst Center X-Auth-Token header
Correct authorization or role after HTTP 403

Correct Answer(s)

Rationale

HTTP GET is intended to query device inventory from an API. It retrieves a resource without requesting a state change. The stem instead requires the team to request a fresh token before repeating a call rejected as unauthenticated; and therefore is not the best fit.
Refresh the API token after HTTP 401 is the best fit because it handles expired or invalid authentication. The case requires the team to request a fresh token before repeating a call rejected as unauthenticated. The choice therefore fits without broadening scope.
Catalyst Center X-Auth-Token header is useful when teams need to use the controller’s documented token header rather than placing the token in a query string. It carries the Catalyst Center access token on API calls. Here the need is to request a fresh token before repeating a call rejected as unauthenticated; so the required behavior is still absent.
Correct authorization or role after HTTP 403 addresses cases that need to fix a call where the token is valid but the account lacks permission for the operation. It addresses authenticated-but-forbidden access. For this question the team must request a fresh token before repeating a call rejected as unauthenticated; so it misses the requirement here.

Question 8

A Cisco network automation engineer is planning a change to grant the required controller role rather than repeatedly reauthenticating a forbidden user. Other controls are already satisfactory. What should be selected for this design? Choose ONE.

HTTP POST
Poll an asynchronous task identifier
Correct the URI or identifier after HTTP 404
Correct authorization or role after HTTP 403

Correct Answer(s)

Rationale

HTTP POST addresses cases that need to create a new controller object through a REST endpoint. It submits data to create or invoke an operation. For this question the team must grant the required controller role rather than repeatedly reauthenticating a forbidden user; leaving the stated need unsatisfied.
Poll an asynchronous task identifier belongs where the goal is to avoid assuming configuration is complete merely because the API accepted the request. It waits for controller-side job completion. This case instead needs grant the required controller role rather than repeatedly reauthenticating a forbidden user; so the required behavior is still absent.
Correct the URI or identifier after HTTP 404 serves designs that must handle deletion or inventory drift when the requested resource no longer exists. It addresses a missing API resource. But this case needs the team to grant the required controller role rather than repeatedly reauthenticating a forbidden user; so it misses the requirement here.
Correct authorization or role after HTTP 403 is the best fit because it addresses authenticated-but-forbidden access. The case requires the team to grant the required controller role rather than repeatedly reauthenticating a forbidden user. It satisfies the case while preserving unrelated controls.

Question 9

A Cisco network automation engineer is evaluating a design that must handle deletion or inventory drift when the requested resource no longer exists. The team wants to avoid custom compensating code. Which mechanism should the architect select? Choose ONE.

HTTP PUT
YANG list key and modeled path
Conflict-aware handling for HTTP 409
Correct the URI or identifier after HTTP 404

Correct Answer(s)

Rationale

HTTP PUT can be appropriate to send the complete desired representation to a REST resource that defines PUT semantics. It replaces a resource representation idempotently. The stated constraint is to handle deletion or inventory drift when the requested resource no longer exists; so the required behavior is still absent.
YANG list key and modeled path solves scenarios that need to build a RESTCONF path that selects a specific modeled list instance. It identifies a unique list entry in structured network data. The design decision here is to handle deletion or inventory drift when the requested resource no longer exists; so it misses the requirement here.
Conflict-aware handling for HTTP 409 is intended to reconcile current state before retrying an operation rejected for conflict. It addresses a resource state conflict. The stem instead requires the team to handle deletion or inventory drift when the requested resource no longer exists; which leaves this requirement unresolved.
Correct the URI or identifier after HTTP 404 is the best fit because it addresses a missing API resource. The case requires the team to handle deletion or inventory drift when the requested resource no longer exists. That is the requested behavior here.

Question 10

A Cisco network automation engineer is correcting an implementation so it can reconcile current state before retrying an operation rejected for conflict. Existing unrelated behavior must remain intact. What is the most appropriate implementation? Choose ONE.

HTTP PATCH
Conflict-aware handling for HTTP 409
json.loads()
HTTP GET

Correct Answer(s)

Rationale

HTTP PATCH normally helps teams change only selected fields without resending the entire object. It applies a partial resource update. The actual requirement is to reconcile current state before retrying an operation rejected for conflict; so it misses the requirement here.
Conflict-aware handling for HTTP 409 is the best fit because it addresses a resource state conflict. The case requires the team to reconcile current state before retrying an operation rejected for conflict. That is the requested behavior here.
json.loads() addresses cases that need to avoid manual string splitting when consuming structured JSON text. It parses a JSON string into Python objects. For this question the team must reconcile current state before retrying an operation rejected for conflict; rather than the decision posed here.
HTTP GET belongs where the goal is to query device inventory from an API. It retrieves a resource without requesting a state change. This case instead needs reconcile current state before retrying an operation rejected for conflict; so it does not meet this constraint.

Question 11

A Cisco network automation engineer has been asked to perform a safe retrieval operation that should not create a new object. The rest of the architecture is already approved. Which option solves the requirement at the correct layer? Choose ONE.

HTTP DELETE
json.dumps()
HTTP GET
HTTP POST

Correct Answer(s)

Rationale

HTTP DELETE belongs where the goal is to delete an API-managed object by its resource URI. It removes the addressed REST resource. This case instead needs perform a safe retrieval operation that should not create a new object; which leaves this requirement unresolved.
json.dumps() serves designs that must emit valid JSON from in-memory Python data. It serializes Python objects into a JSON string. But this case needs the team to perform a safe retrieval operation that should not create a new object; rather than the decision posed here.
HTTP GET is the best fit because it retrieves a resource without requesting a state change. The case requires the team to perform a safe retrieval operation that should not create a new object. This addresses the requirement at the intended layer.
HTTP POST solves scenarios that need to create a new controller object through a REST endpoint. It submits data to create or invoke an operation. The design decision here is to perform a safe retrieval operation that should not create a new object; which is a different design problem.

Question 12

A Cisco network automation engineer needs a solution that can invoke an action-style API whose documentation requires a POST body. The decision must follow the platform’s intended semantics. What should the team use? Choose ONE.

Content-Type header
response.json()
HTTP POST
HTTP PUT

Correct Answer(s)

Rationale

Content-Type header solves scenarios that need to tell a REST API that the payload being sent is JSON. It describes the media type of the request body. The design decision here is to invoke an action-style API whose documentation requires a POST body; rather than the decision posed here.
response.json() is intended to avoid separately passing response text to a JSON parser. It decodes JSON directly from an HTTP response. The stem instead requires the team to invoke an action-style API whose documentation requires a POST body; so it does not meet this constraint.
HTTP POST is the best fit because it submits data to create or invoke an operation. The case requires the team to invoke an action-style API whose documentation requires a POST body. That makes it the narrowest correct answer.
HTTP PUT is useful when teams need to send the complete desired representation to a REST resource that defines PUT semantics. It replaces a resource representation idempotently. Here the need is to invoke an action-style API whose documentation requires a POST body; and therefore is not the best fit.

Question 13

A Cisco network automation engineer must choose a mechanism to choose replacement semantics rather than a partial field change. No broader redesign is requested. Which approach addresses the stated constraint? Choose ONE.

Accept header
HTTP PUT
response.raise_for_status()
HTTP PATCH

Correct Answer(s)

Rationale

Accept header is useful when teams need to ask a RESTCONF service to return JSON rather than XML where supported. It requests a preferred response representation. Here the need is to choose replacement semantics rather than a partial field change; so it does not meet this constraint.
HTTP PUT is the best fit because it replaces a resource representation idempotently. The case requires the team to choose replacement semantics rather than a partial field change. It satisfies the case while preserving unrelated controls.
response.raise_for_status() belongs where the goal is to route HTTP failures into exception handling without manually testing every status code. It raises exceptions for unsuccessful HTTP responses. This case instead needs choose replacement semantics rather than a partial field change; and therefore is not the best fit.
HTTP PATCH serves designs that must change only selected fields without resending the entire object. It applies a partial resource update. But this case needs the team to choose replacement semantics rather than a partial field change; leaving the stated need unsatisfied.

Question 14

A Cisco network automation engineer has this requirement: preserve unspecified resource fields while applying a targeted update. Unrelated availability and identity settings must not change. Which option is the best fit? Choose ONE.

Catalyst Center X-Auth-Token header
Explicit HTTP timeout
HTTP PATCH
HTTP DELETE

Correct Answer(s)

Rationale

Catalyst Center X-Auth-Token header serves designs that must authenticate subsequent Catalyst Center requests after obtaining the token. It carries the Catalyst Center access token on API calls. But this case needs the team to preserve unspecified resource fields while applying a targeted update; which is a different design problem.
Explicit HTTP timeout can be appropriate to make request latency failure deterministic for an orchestration pipeline. It bounds how long an automation request waits. The stated constraint is to preserve unspecified resource fields while applying a targeted update; and therefore is not the best fit.
HTTP PATCH is the best fit because it applies a partial resource update. The case requires the team to preserve unspecified resource fields while applying a targeted update. That property directly matches the constraint.
HTTP DELETE is intended to delete an API-managed object by its resource URI. It removes the addressed REST resource. The stem instead requires the team to preserve unspecified resource fields while applying a targeted update; so the required behavior is still absent.

Question 15

A Cisco network automation engineer is reviewing how to remove YANG-modeled data through a RESTCONF endpoint that supports DELETE. The change should be limited to the relevant layer. Which choice most directly meets the requirement? Choose ONE.

Poll an asynchronous task identifier
Exponential backoff retry
Content-Type header
HTTP DELETE

Correct Answer(s)

Rationale

Poll an asynchronous task identifier is intended to track a long-running controller operation after the initial request returns a task reference. It waits for controller-side job completion. The stem instead requires the team to remove YANG-modeled data through a RESTCONF endpoint that supports DELETE; and therefore is not the best fit.
Exponential backoff retry normally helps teams retry temporary 5xx failures with increasing delays. It spaces retries after transient throttling or server errors. The actual requirement is to remove YANG-modeled data through a RESTCONF endpoint that supports DELETE; leaving the stated need unsatisfied.
Content-Type header is useful when teams need to differentiate request-body encoding from the response format the client would prefer. It describes the media type of the request body. Here the need is to remove YANG-modeled data through a RESTCONF endpoint that supports DELETE; so the required behavior is still absent.
HTTP DELETE is the best fit because it removes the addressed REST resource. The case requires the team to remove YANG-modeled data through a RESTCONF endpoint that supports DELETE. The design gets the required behavior with this option.

Question 16

A Cisco network automation engineer is planning a change to differentiate request-body encoding from the response format the client would prefer. Only this stated constraint is driving the decision. What should be selected for this design? Choose ONE.

Content-Type header
YANG list key and modeled path
Refresh the API token after HTTP 401
Accept header

Correct Answer(s)

Rationale

Content-Type header is the best fit because it describes the media type of the request body. The case requires the team to differentiate request-body encoding from the response format the client would prefer. This addresses the requirement at the intended layer.
YANG list key and modeled path belongs where the goal is to build a RESTCONF path that selects a specific modeled list instance. It identifies a unique list entry in structured network data. This case instead needs differentiate request-body encoding from the response format the client would prefer; so the required behavior is still absent.
Refresh the API token after HTTP 401 serves designs that must request a fresh token before repeating a call rejected as unauthenticated. It handles expired or invalid authentication. But this case needs the team to differentiate request-body encoding from the response format the client would prefer; so it misses the requirement here.
Accept header can be appropriate to ask a RESTCONF service to return JSON rather than XML where supported. It requests a preferred response representation. The stated constraint is to differentiate request-body encoding from the response format the client would prefer; which leaves this requirement unresolved.

Question 17

A Cisco network automation engineer is evaluating a design that must separate response-content negotiation from the encoding of the request body. The team wants the most specific native mechanism. Which mechanism should the architect select? Choose ONE.

json.loads()
Correct authorization or role after HTTP 403
Catalyst Center X-Auth-Token header
Accept header

Correct Answer(s)

Rationale

json.loads() can be appropriate to turn an API response string already stored in memory into a Python dictionary or list. It parses a JSON string into Python objects. The stated constraint is to separate response-content negotiation from the encoding of the request body; so the required behavior is still absent.
Correct authorization or role after HTTP 403 solves scenarios that need to separate authorization policy failure from token-expiration handling. It addresses authenticated-but-forbidden access. The design decision here is to separate response-content negotiation from the encoding of the request body; so it misses the requirement here.
Catalyst Center X-Auth-Token header is intended to use the controller’s documented token header rather than placing the token in a query string. It carries the Catalyst Center access token on API calls. The stem instead requires the team to separate response-content negotiation from the encoding of the request body; which leaves this requirement unresolved.
Accept header is the best fit because it requests a preferred response representation. The case requires the team to separate response-content negotiation from the encoding of the request body. That is the requested behavior here.

Question 18

A Cisco network automation engineer is correcting an implementation so it can use the controller’s documented token header rather than placing the token in a query string. The implementation should not expand scope beyond this need. What is the most appropriate implementation? Choose ONE.

Catalyst Center X-Auth-Token header
json.dumps()
Correct the URI or identifier after HTTP 404
Poll an asynchronous task identifier

Correct Answer(s)

Rationale

Catalyst Center X-Auth-Token header is the best fit because it carries the Catalyst Center access token on API calls. The case requires the team to use the controller’s documented token header rather than placing the token in a query string. The scenario depends on exactly that capability.
json.dumps() is useful when teams need to emit valid JSON from in-memory Python data. It serializes Python objects into a JSON string. Here the need is to use the controller’s documented token header rather than placing the token in a query string; which leaves this requirement unresolved.
Correct the URI or identifier after HTTP 404 addresses cases that need to handle deletion or inventory drift when the requested resource no longer exists. It addresses a missing API resource. For this question the team must use the controller’s documented token header rather than placing the token in a query string; rather than the decision posed here.
Poll an asynchronous task identifier belongs where the goal is to track a long-running controller operation after the initial request returns a task reference. It waits for controller-side job completion. This case instead needs use the controller’s documented token header rather than placing the token in a query string; so it does not meet this constraint.

Question 19

A Cisco network automation engineer has been asked to retrieve task status until the controller reports success or failure. The selected control should solve this condition directly. Which option solves the requirement at the correct layer? Choose ONE.

Poll an asynchronous task identifier
response.json()
Conflict-aware handling for HTTP 409
YANG list key and modeled path

Correct Answer(s)

Rationale

Poll an asynchronous task identifier is the best fit because it waits for controller-side job completion. The case requires the team to retrieve task status until the controller reports success or failure. That property directly matches the constraint.
response.json() serves designs that must avoid separately passing response text to a JSON parser. It decodes JSON directly from an HTTP response. But this case needs the team to retrieve task status until the controller reports success or failure; rather than the decision posed here.
Conflict-aware handling for HTTP 409 can be appropriate to reconcile current state before retrying an operation rejected for conflict. It addresses a resource state conflict. The stated constraint is to retrieve task status until the controller reports success or failure; so it does not meet this constraint.
YANG list key and modeled path solves scenarios that need to address one interface entry in a YANG list using its key. It identifies a unique list entry in structured network data. The design decision here is to retrieve task status until the controller reports success or failure; which is a different design problem.

Question 20

A Cisco network automation engineer needs a solution that can distinguish one repeated YANG list item from a singleton container. Other controls are already satisfactory. What should the team use? Choose ONE.

response.raise_for_status()
YANG list key and modeled path
HTTP GET
json.loads()

Correct Answer(s)

Rationale

response.raise_for_status() solves scenarios that need to fail fast when a Python requests call returns a 4xx or 5xx status. It raises exceptions for unsuccessful HTTP responses. The design decision here is to distinguish one repeated YANG list item from a singleton container; rather than the decision posed here.
YANG list key and modeled path is the best fit because it identifies a unique list entry in structured network data. The case requires the team to distinguish one repeated YANG list item from a singleton container. The design gets the required behavior with this option.
HTTP GET normally helps teams perform a safe retrieval operation that should not create a new object. It retrieves a resource without requesting a state change. The actual requirement is to distinguish one repeated YANG list item from a singleton container; which is a different design problem.
json.loads() is useful when teams need to turn an API response string already stored in memory into a Python dictionary or list. It parses a JSON string into Python objects. Here the need is to distinguish one repeated YANG list item from a singleton container; and therefore is not the best fit.

All Certifications, Certifications

Related posts:

Leave a Reply Cancel reply