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

Question 1

A developer is preparing a Python application that reads the API base URL and an API token from the environment. The developer wants to avoid hard-coding credentials and intends to deploy the same artifact to a lab and a production environment. Which approach should be used?

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

Accepted Answer

Read the base URL and token from environment variables at runtime, supplying different values per deployment environment.. Injecting configuration through environment variables separates code from environment-specific values and keeps secrets out of the repository. The same artifact can be promoted from lab to production because the base URL and token are supplied by the runtime platform, not compiled in. This is a standard twelve-factor configuration practice for cloud-native and containerized applications.

Answer

Embed the base URL and token as default arguments in the Python function signatures so they are easy to find.

Answer

Prompt the user interactively for the base URL and token each time the application starts.

Answer

Store the base URL and token in a configuration file that is committed to the Git repository, and read it at startup.

Question 2

A developer is preparing to add a new feature to a shared Git repository. The team uses a workflow where each feature is developed on its own branch and then merged back into the main branch through a pull request. Which Git operation should the developer perform first to begin work on the new feature?

Accepted Answer

git checkout -b feature/new-feature. Starting a feature requires an isolated branch so commits do not land directly on the shared main branch. Creating and switching to a new branch in one step provides that isolation and prepares the work for a later pull request. Committing, pushing main, or merging does not establish the new branch.

Answer

git merge main

Answer

git push origin main

Answer

git commit -m "start feature"

Question 3

A developer is writing unit tests for a Python function that parses Cisco IOS configuration text and returns a dictionary of interfaces. The function relies on an external file read. Which TWO practices improve the testability and reliability of these unit tests? (Choose two.)

Accepted Answer

Use unittest.mock.patch to replace the file read with a mock that returns fixed configuration text. Mocking the file read with unittest.mock.patch and using pytest.mark.parametrize both improve testability: mocking removes external dependencies, and parametrization increases coverage with minimal code. Relying on live devices, merging assertions, or adding sleep delays all reduce reliability and speed, making them poor choices for unit tests.

Answer

Place all test assertions inside a single test function to minimize the number of test cases

Answer

Write tests that depend on a live Cisco device reachable over SSH to fetch real configuration

Answer

Use time.sleep to wait for the file read to complete before asserting results

Question 4

A developer is writing a Python function that accepts a list of interface names and returns a dictionary mapping each interface name to the number of characters in that name. The function should also verify that the input is a list and raise a TypeError otherwise. Which approach correctly implements the described behavior?

Accepted Answer

def map_lengths(names):
    if not isinstance(names, list):
        raise TypeError('names must be a list')
    return {n: len(n) for n in names}. The requirement is twofold: validate that the argument is a list and raise TypeError when it is not, then return a dictionary of name to length. Only the implementation using isinstance with a TypeError raise and a dictionary comprehension satisfies both constraints in a single, correct function.

Answer

def map_lengths(names):
    if type(names) != list:
        raise ValueError('names must be a list')
    return {n: n.__len__() for n in names}

Answer

def map_lengths(names):
    assert isinstance(names, list)
    return dict(zip(names, map(len, names)))

Answer

def map_lengths(names): return {n: len(n) for n in names}

Question 5

A developer is working on a Git repository and needs to temporarily save changes that are not ready to be committed, switch to another branch to fix a bug, and then return to the original branch and reapply the saved changes. Which Git command should be used to accomplish this?

Accepted Answer

git stash. git stash is designed to temporarily save uncommitted changes, allowing a clean working directory to switch branches. After handling the urgent bug fix, the developer can return and reapply the stashed changes. The other options either commit, discard, or misconfigure branches, none of which preserve work-in-progress.

Answer

git checkout -- .

Answer

git branch --set-upstream-to

Answer

git commit -m "WIP"

Question 6

A developer is reviewing a Python script that makes a REST API call using the requests library. The script must set a custom HTTP header 'X-Auth-Token' with a value from an environment variable. Which code snippet correctly adds this header to the request?

Accepted Answer

requests.get(url, headers={'X-Auth-Token': os.environ['TOKEN']}). The requests library accepts a headers parameter as a dictionary to set custom HTTP headers. Passing {'X-Auth-Token': os.environ['TOKEN']} correctly adds the token header while keeping the secret out of source code. The auth parameter is for basic authentication, params adds query strings, and data sets the request body, none of which fulfill the need for a custom header.

Answer

requests.get(url, auth=('X-Auth-Token', os.environ['TOKEN']))

Answer

requests.get(url, params={'X-Auth-Token': os.environ['TOKEN']})

Answer

requests.get(url, data={'X-Auth-Token': os.environ['TOKEN']})

Question 7

A developer is building a Python function that must parse a JSON payload returned by a Cisco DNA Center API. The function needs to gracefully handle cases where the JSON is malformed or the response body is empty, without crashing the calling script. Which approach best meets this requirement?

Accepted Answer

Wrap json.loads() in a try/except json.JSONDecodeError block and return a default value or raise a custom exception when parsing fails.. The function must isolate JSON parsing failures so the caller is not disrupted by malformed or empty responses. Catching json.JSONDecodeError around json.loads() and returning a default or raising a custom exception centralizes error handling and provides a predictable interface. The other choices either propagate exceptions, introduce security risks with eval(), or defer parsing without handling errors.

Answer

Use eval() to interpret the response body, since eval() can parse both JSON and Python literals.

Answer

Check if the response body is empty and, if not, pass it directly to the rest of the application as a string.

Answer

Call json.loads() on the response body and let any exception propagate to the caller.

Question 8

A developer is preparing a Python script that will be shared with a team and run in multiple environments. The script relies on several third-party libraries. Which TWO practices should be followed to ensure reproducible dependency management? (Choose two.)

Accepted Answer

Pin exact versions of dependencies in a requirements.txt file using the == operator.. Reproducible dependency management requires isolating project packages and recording exact versions. A virtual environment prevents interference from system-wide packages, while pinning versions in requirements.txt ensures that every installation uses the same releases. Together they allow any team member or CI system to recreate the exact environment. Global installs, unpinned versions, and committing the virtual environment all introduce variability and are not recommended.

Answer

Install packages globally with pip install --user to avoid permission issues.

Answer

Commit the entire virtual environment directory to the Git repository.

Answer

Rely on the latest versions of dependencies by omitting version specifiers in requirements.txt.

Question 9

A developer is writing unit tests for a Python module that parses show command output from network devices. The tests must be deterministic and must not depend on real devices or the network. Which TWO practices should the developer apply? (Choose two.)

Accepted Answer

Use unittest.mock to replace the function that opens an SSH connection to the device with a stub that returns captured output.. Deterministic, device-independent parsing tests come from replacing live I/O with controlled substitutes and asserting against known data. Mocking the SSH layer removes network dependency, while fixture files supply stable input and expected results. Together these practices make the unit tests repeatable and safe to run in CI without any real routers or switches.

Answer

Run the test suite against a production router to confirm the parser handles real output.

Answer

Run tests only in a lab environment where devices are always powered on and reachable.

Answer

Add time.sleep calls between assertions to allow the device to respond before checking results.

Question 10

A developer is writing a Python script that must process a large list of network device hostnames. The script needs to read each hostname, perform a blocking SSH operation, and then move to the next hostname. The developer wants to make the code more efficient by using a generator function to yield hostnames one at a time instead of loading the entire list into memory. Which Python construct should the developer use to define this generator?

Accepted Answer

def get_hostnames(hosts):
    for h in hosts:
        yield h. A generator function is defined using the yield keyword inside a function. When called, it returns a generator object that produces values on demand, which is perfect for iterating over large datasets without loading everything into memory. The other options either create a full list or use a different construct that does not meet the requirement of a generator function.

Answer

def get_hostnames(hosts):
    return [h for h in hosts]

Answer

def get_hostnames(hosts):
    return (h for h in hosts)

Answer

class HostnameGenerator:
    def __init__(self, hosts):
        self.hosts = hosts
    def __iter__(self):
        return iter(self.hosts)

Question 11

A developer is building a Python client that calls a REST API returning JSON. The client must detect authentication failures, rate limiting, and server errors so it can retry or alert appropriately. Which coding practice should be applied?

Accepted Answer

Inspect the response status code and branch on categories such as 401/403 for authentication, 429 for rate limiting, and 5xx for server errors before processing the body.. HTTP status codes carry the outcome of each request, so a robust client branches on them: refresh credentials on 401, respect Retry-After and back off on 429, and alert on 5xx. Parsing the body is meaningful only after the status indicates success. This ordering lets the client retry the conditions that are transient and escalate the ones that are not.

Answer

Call response.json() immediately after every request and catch only json.JSONDecodeError, since valid JSON indicates success.

Answer

Set a long socket timeout and retry indefinitely on any exception until the request succeeds.

Answer

Wrap every request in a bare try/except that logs the exception and returns an empty list so the caller never fails.

Question 12

A developer is using Git to contribute to a shared repository. After making several commits on a local feature branch, the developer wants to integrate the latest changes from the remote main branch into the feature branch while keeping a linear history. Which Git command should be used?

Accepted Answer

git rebase main. To integrate upstream changes while keeping a linear history, the feature branch commits must be replayed on top of the updated main. git rebase main performs exactly this operation, moving the branch pointer and rewriting commits so that the history appears as if the feature was developed after the latest main. Merging or pulling would create a merge commit, and cherry-pick does not apply the full set of changes.

Answer

git merge main

Answer

git pull origin main

Answer

git cherry-pick main

Question 13

A developer is building a Python script that calls a REST API which returns a JSON payload containing a list of interfaces. The script must parse the response and extract the 'name' field from each interface object. Which approach correctly uses the requests library to parse the JSON and iterate over the interfaces?

Accepted Answer

response = requests.get(url); interfaces = response.json(); for intf in interfaces['interfaces']: print(intf['name']). The requests library's Response object provides a .json() method that deserializes the JSON response body into Python objects. After calling .json(), the result is typically a dictionary or list that can be indexed and iterated. Using response.json() is the idiomatic way to parse JSON in requests, and the subsequent iteration extracts the 'name' field from each interface dictionary.

Answer

response = requests.get(url); interfaces = json.loads(response); for intf in interfaces['interfaces']: print(intf['name'])

Answer

response = requests.get(url); interfaces = response.json; for intf in interfaces['interfaces']: print(intf['name'])

Answer

response = requests.get(url); interfaces = response.text; for intf in interfaces['interfaces']: print(intf['name'])

Question 14

A developer maintains a Python library that calls a REST API and currently stores the API token in a module-level constant. The team wants to follow twelve-factor app principles so the same build artifact can be deployed to lab and production without code changes. Which change should the developer make?

Accepted Answer

Read the token from an environment variable, such as os.environ['API_TOKEN'], at runtime.. Twelve-factor configuration is stored in the environment, not in code or committed files. Reading the API token from an environment variable allows the identical build artifact to run in lab and production with different credentials, keeps secrets out of source control, and requires no code edits between deployments.

Answer

Move the token into a config.ini file that is committed to the repository and read at import time.

Answer

Encrypt the token with a symmetric key and store both the ciphertext and key in the repository for decryption at runtime.

Answer

Detect the deployment environment by hostname and select a hardcoded token for each environment.

Question 15

A developer is building a Python application that must handle configuration data in multiple formats (JSON, YAML, XML) and provide a consistent interface for reading and writing. The application may add new formats later. Which design pattern best supports this extensibility while keeping the client code decoupled from concrete implementations?

Accepted Answer

Factory method pattern with an abstract parser interface. The factory method pattern is ideal because it encapsulates object creation, letting the client work with an abstract parser interface while subclasses or factory methods handle instantiation of concrete parsers for JSON, YAML, or XML. This decouples client code from specific formats and allows new formats to be added without changing existing code, satisfying extensibility.

Answer

Singleton pattern with a global configuration manager

Answer

Observer pattern to notify components when configuration changes

Answer

Adapter pattern to convert each format to a common internal representation