200-901 Software Development and Design Practice Test 8 — 15 Questions

Question 1

A developer is designing a Python application that must handle failures when making REST API calls to a Cisco DNA Center controller. The application should retry a failed request only if the HTTP status code indicates a server-side error (5xx) or a timeout occurs, but should not retry on client errors (4xx). The developer wants to implement this using a decorator. Which Python library provides a ready-to-use retry decorator that can be configured to retry on specific exceptions and HTTP status codes?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

tenacity. Tenacity is a dedicated retrying library that offers a decorator with extensive configuration options, including retrying on specific exceptions and stop conditions. It can be easily integrated with HTTP status code checks. The other libraries either lack a retry decorator or require manual implementation, making tenacity the correct choice for this scenario.

Answer

urllib3

Answer

functools

Answer

requests

Question 2

A developer clones a shared repository and creates a feature branch, but a teammate pushes a commit to the main branch that conflicts with local edits. The developer wants to bring those upstream changes into the feature branch and resolve conflicts before opening a pull request. Which Git operation should be used?

Accepted Answer

git merge main while the feature branch is checked out. Merging main into the checked-out feature branch brings the upstream commits into the feature branch and presents conflicts in the working tree for resolution. The feature branch retains its own commits, and the resulting state can be pushed for review. This is the conventional pre-pull-request integration step when a teammate has advanced the main branch.

Answer

git stash pop after fetching main

Answer

git revert main while the feature branch is checked out

Answer

git reset --hard main while the feature branch is checked out

Question 3

A developer is working on a Git repository and needs to temporarily save changes that are not ready to be committed so they can switch to another branch to fix a bug. Which Git command should the developer use to stash the current changes?

Accepted Answer

git stash. The git stash command is designed to temporarily store modifications to tracked files and the staging area, allowing a clean working directory. This enables switching branches or performing other operations without committing incomplete work. The stashed changes can be reapplied later with git stash pop or git stash apply, making it ideal for the described scenario.

Answer

git commit -m "WIP"

Answer

git branch temp

Answer

git checkout -- .

Question 4

A developer is creating a Python function that must parse a JSON response from a Cisco DNA Center API. The function should handle cases where a key may be missing without crashing. Which approach best achieves this?

Accepted Answer

Use response.json().get('key', default_value) to retrieve values with a fallback.. The get() method on a dictionary provides a safe way to access keys that may be absent, returning a default value instead of raising an exception. This is particularly useful when parsing JSON from APIs where fields are optional. The other options either rely on error-prone exception handling, are overly complex, or use inappropriate parsing techniques. Using get() results in clean, robust code.

Answer

Convert the JSON response to a string and use regular expressions to extract values.

Answer

Use a try/except block around each key access to catch KeyError and assign a default.

Answer

Use response.json() and access keys directly with square brackets, relying on exception handling.

Question 5

A team is containerizing a Python API service so it can run identically on developer laptops and in production. Which TWO practices support reproducible, portable container images for this service? (Choose two.)

Accepted Answer

Pin the base image to a specific digest and declare exact dependency versions in a lock file installed during the build.. Reproducibility requires that the same inputs always produce the same image, which means pinning the base image and locking dependencies. Portability requires that environment differences be supplied at runtime, not baked in, so one tested artifact can move from laptop to production unchanged. Together these practices make builds deterministic and keep secrets out of image layers.

Answer

Bake environment-specific API tokens and database passwords into the image as build arguments so the container starts ready to use.

Answer

Install dependencies from the public index without version constraints and rebuild the image on every deployment to pick up the latest packages.

Answer

Mount the developer's local source directory over the application path inside the production container to keep code current.

Question 6

A developer is writing a Python function that accepts a variable number of interface names and returns them as a tuple. Which function definition correctly allows an arbitrary number of positional arguments?

Accepted Answer

def list_interfaces(*interfaces):. The function must accept a variable number of positional arguments. Using *interfaces packs all positional arguments into a tuple, which is exactly what the scenario requires. The other definitions either accept a single argument, collect keyword arguments into a dictionary, or use a mutable default that introduces bugs and still does not support multiple positional arguments.

Answer

def list_interfaces(interfaces):

Answer

def list_interfaces(**interfaces):

Answer

def list_interfaces(interfaces=[]):

Question 7

A developer is writing unit tests for a Python function that interacts with a REST API. Which TWO practices are recommended to ensure tests are reliable and isolated? (Choose two.)

Accepted Answer

Mock external HTTP requests using a library like unittest.mock or responses.. Mocking external HTTP requests and asserting on the function's output are key to reliable unit tests. Mocking isolates the code under test from external dependencies, while assertions validate correct behavior. Together, they ensure tests are fast, deterministic, and focused on logic. The other practices either introduce dependencies or do not address isolation and reliability.

Answer

Include delays between test cases to simulate network latency.

Answer

Run tests in parallel to reduce execution time.

Answer

Use real API endpoints to ensure the function works with actual data.

Question 8

A developer is preparing a Python script that will be committed to a shared Git repository used by a team of network automation engineers. The team wants to ensure that sensitive credentials and environment-specific files are never committed. Which TWO actions should the developer take? (Choose two.)

Accepted Answer

Use environment variables to supply credentials at runtime instead of hardcoding them.. The team needs to prevent sensitive files from entering Git. A .gitignore file excludes specified files and patterns from being tracked, and using environment variables for credentials means secrets never need to be stored in the repository. Committing credentials even temporarily, storing them in documentation, or relying on manual unstaging all risk exposing secrets and do not provide a reliable safeguard.

Answer

Store the credentials in a README.md file so the team can easily find them.

Answer

Run git add . to stage all files, then manually unstage credentials before committing.

Answer

Commit the credentials file once, then delete it in a later commit.

Question 9

A developer is using Git to manage a project. They need to temporarily save changes that are not ready to be committed so they can switch to another branch. Which Git command should they use?

Accepted Answer

git stash. git stash is designed to temporarily save uncommitted changes, allowing a clean working directory to switch branches or perform other operations. It preserves the changes for later retrieval. The other commands either discard changes, create permanent commits, or do not save changes at all, making them unsuitable for this scenario.

Answer

git commit -m 'WIP'

Answer

git reset --hard

Answer

git branch new-branch

Question 10

A developer is writing unit tests for a Python function that parses JSON responses from a Cisco Meraki API. The function takes a JSON string and returns a dictionary. The developer wants to follow best practices for unit testing. Which TWO of the following are recommended practices when writing these tests? (Choose two.)

Accepted Answer

Include at least one test case for invalid JSON input to verify error handling.. Best practices for unit testing include isolating the code under test from external dependencies using test doubles, and covering edge cases such as invalid input. These practices ensure tests are fast, reliable, and comprehensive. The other options describe anti-patterns like order dependence and monolithic tests, which reduce test effectiveness.

Answer

Assert only on the final output of the function, ignoring intermediate states.

Answer

Write tests that depend on the order of execution to save time.

Answer

Use a single test function that covers all possible edge cases to reduce the number of tests.

Question 11

A developer is troubleshooting a Python function that parses device configuration returned by a REST API. The function receives a JSON string and must convert it into native Python dictionaries and lists before iterating over the device entries. Which standard-library approach performs that conversion?

Accepted Answer

Call json.loads() on the response text to transform the JSON string into Python dictionaries and lists.. The json module separates file-based and string-based operations. Deserializing in-memory API text requires json.loads(), which turns JSON text into dicts, lists, strings, numbers, booleans, and None. The serializing counterpart json.dumps() moves in the other direction, and json.load() requires a file-like object rather than a string.

Answer

Call json.load() on the response text to read the JSON content directly from the string variable.

Answer

Call str() on the response text so Python can interpret the JSON braces and brackets as native container syntax.

Answer

Call json.dumps() on the response text to transform the JSON string into Python dictionaries and lists.

Question 12

A developer is writing a Python unit test for a function that parses interface status from a network device. The function raises a custom exception called InterfaceDownError when an interface is administratively down. Which unittest assertion correctly verifies that calling parse_interface('down') raises InterfaceDownError?

Accepted Answer

self.assertRaises(InterfaceDownError, parse_interface, 'down'). The unittest framework provides assertRaises specifically for verifying that a callable raises a particular exception when invoked with given arguments. It calls parse_interface('down') and succeeds only if InterfaceDownError is raised. The other assertions either compare values, invoke the function outside an exception context, or check types incorrectly, so they do not validate the exception behavior.

Answer

self.assertTrue(parse_interface('down') == InterfaceDownError)

Answer

self.assertEqual(parse_interface, 'down')

Answer

self.assertIsInstance(parse_interface, InterfaceDownError)

Question 13

A developer is designing a Python script that must authenticate to a Cisco Meraki API using an API key. The key should not be hardcoded in the script. Which method is most secure for managing the API key?

Accepted Answer

Use environment variables to pass the API key to the script.. Using environment variables is a secure and standard way to manage secrets like API keys. It keeps them out of code and version control, and allows different environments to use different keys. The other options either store the key insecurely, use reversible obfuscation, or are impractical for automation. Environment variables strike a balance between security and usability.

Answer

Prompt the user to enter the API key each time the script runs.

Answer

Hardcode the API key in the script but obfuscate it using Base64 encoding.

Answer

Store the API key in a configuration file and read it at runtime.

Question 14

A developer is using Git for version control in a collaborative project and wants to ensure a clean, linear history. Which TWO practices help achieve a linear commit history? (Choose two.)

Accepted Answer

Use git rebase to integrate changes from the main branch into a feature branch before merging.. To maintain a linear commit history, developers should rebase feature branches onto the main branch before merging and use git pull --rebase when updating from a remote. These practices avoid merge commits and keep the commit graph as a straight line. They are widely adopted in teams that prioritize a clean, readable history.

Answer

Use git merge with the --no-ff flag to always create a merge commit.

Answer

Use git commit --amend to modify the most recent commit.

Answer

Use git cherry-pick to apply specific commits from one branch to another.

Question 15

A developer is preparing a Python script that authenticates to a Cisco DNA Center controller, retrieves a list of network devices, and writes the inventory into a reusable module consumed by other teams. The team lead requires that the credentials never be stored in the source code. Which TWO practices satisfy that requirement? (Choose two.)

Accepted Answer

Load the credentials from a separate configuration file that is listed in .gitignore and provisioned on each host.. Secrets must be injected from outside the repository so that committed code never contains them. Environment variables and an ignored, per-host configuration file both achieve this, letting each consumer supply its own values while the module itself holds only the logic that reads them. Encoding or renaming secrets inside the source leaves the values in version history.

Answer

Encode the credentials with base64 inside the module so they are unreadable to anyone browsing the source.

Answer

Commit the credentials in an encrypted form and keep the decryption key in the same repository branch for convenience.

Answer

Hard-code the credentials as module-level constants but rename the variables so they are not obviously credentials.