JNCIA-DevOps Python And PyEZ Practice Test 5 — 15 Questions

Question 1

You are utilizing PyEZ Table and View abstractions to parse interface statistics. Which base class must your custom Table class inherit from to map to Junos XML output?

Accepted Answer

jnpr.junos.factory.Table. To leverage PyEZ Table/View mapping for operational commands, your custom table class must inherit from 'jnpr.junos.factory.Table'.

Answer

jnpr.junos.rpchandler.RPC

Answer

jnpr.junos.device.Device

Answer

jnpr.junos.utils.config.Config

Question 2

When implementing Jinja2 templates for Junos configuration generation, which THREE features or syntax constructs are natively supported by the Jinja2 engine?

Accepted Answer

Variable substitution using double curly braces (e.g., {{ interface_name }}). Jinja2 natively supports variable substitution through double curly braces, so option C ({{ interface_name }}) is correct because the engine evaluates the expression and renders its value into the output. Option D is correct because Jinja2 provides control structures such as {% for item in list %} loops and {% if %} conditional blocks that are evaluated during rendering. Option E is correct because Jinja2 supports template inheritance via {% extends %} and overridable {% block content %} sections, allowing a base template to be reused and customized. Option A is not a Jinja2 feature; Jinja2 renders text and does not automatically translate its syntax into NETCONF XML filters, which is handled by Junos-specific tooling such as PyEZ or Jinja2 filters written for that purpose. Option B is also not native Jinja2 behavior; arbitrary host-level Bash execution is not part of the template engine and would require custom extensions or filters, not standard Jinja2 syntax.

Answer

Automatic translation of Jinja2 syntax into NETCONF XML filters without evaluation

Answer

Direct execution of arbitrary host-level Bash shell scripts inside template bodies

Question 3

Which TWO actions can be performed using the JSNAPy command-line interface (CLI) tool during network verification workflows?

Accepted Answer

Capturing operational state snapshots of devices defined in configuration files. JSNAPy (Junos Snapshot Administrator in Python) is a CLI tool designed for network verification workflows, and option A is correct because its core function is to capture operational state snapshots from devices listed in the jsnapy.cfg configuration file using commands like 'jsnapy --snapcheck' or 'jsnapy --snap'. Option C is also correct because JSNAPy's primary purpose is to compare pre-change and post-change snapshots against test assertions defined in YAML test files, executed via 'jsnapy --check' or 'jsnapy --diff', to validate that network state matches expected values. The unmarked options do not belong: ZTP DHCP server scope provisioning (B) is a configuration task unrelated to JSNAPy's snapshot/verification role, compiling Junos routing daemon binaries (D) is an internal Juniper build process not exposed through JSNAPy, and translating PyEZ scripts into SLAX op scripts (E) is not a JSNAPy capability since JSNAPy consumes PyEZ but does not perform such translation.

Answer

Provisioning zero-touch deployment (ZTP) DHCP server scopes on core switches

Answer

Directly compiling Junos Source routing daemon binaries

Answer

Translating PyEZ Python scripts into native Junos SLAX op scripts

Question 4

You are writing a Python script that uses PyEZ to connect to a Junos device. After calling `dev.open()`, you need to verify that the NETCONF session is active before performing operational commands. Which statement correctly checks the connection status and returns a Boolean value?

Accepted Answer

`dev.connected`. The `connected` property is a read-only Boolean that reflects whether the NETCONF session is currently open. After calling `open()`, checking `dev.connected` confirms the session is active before sending operational commands. Other options are not valid PyEZ attributes or methods for this check.

Answer

`dev.is_open()`

Answer

`dev.status()`

Answer

`dev.session`

Question 5

A Python script using PyEZ loads a configuration from a file and commits it on a Junos device. The commit fails with a `CommitError` exception. You need to retrieve the specific error message returned by the device. Which method or attribute should you use to obtain the detailed error text?

Accepted Answer

`exception.errs`. When a commit fails, PyEZ raises `CommitError` with an `errs` attribute containing a list of error details from the device. Iterating over `exception.errs` provides the specific commit error messages. Other attributes like `message`, `detail`, or `response` are not the correct way to retrieve these details.

Answer

`exception.detail`

Answer

`exception.message`

Answer

`exception.response`

Question 6

You are using PyEZ to retrieve the operational status of all interfaces on a Junos device. You want to get the output in a structured Python dictionary rather than raw XML. Which method should you use on the Device object?

Accepted Answer

`dev.rpc.get_interface_information(normalize=True)`. To get structured dictionary output from an RPC in PyEZ, use the `normalize=True` parameter. This converts the XML response into a Python dictionary. Other methods either return XML, facts, or raw text, and do not provide the interface status as a dictionary.

Answer

`dev.facts`

Answer

`dev.rpc.get_interface_information()`

Answer

`dev.cli('show interfaces')`

Question 7

You are writing a Python script using PyEZ to retrieve and process operational data from a Junos device. Which TWO statements correctly describe the use of PyEZ Table and View for parsing operational data? (Choose two.)

Accepted Answer

A View defines how to extract specific fields from the XML response of an RPC.. A View defines the extraction of fields from XML, and a Table uses that View to parse RPC output into a list of dictionaries. The other statements are incorrect: Tables do not auto-convert to JSON, Views can be in Python, and Tables are for operational data.

Answer

Views must be defined in a separate YAML file and cannot be coded in Python.

Answer

Tables automatically convert all XML responses into JSON format.

Answer

Tables can only retrieve configuration data, not operational data.

Question 8

You are automating the retrieval of operational data from a Junos device using PyEZ. You write a Python script that calls the RPC method `get_interface_information` with the argument `terse=True` on a `Device` object. The script executes successfully, but the returned XML contains only a subset of interface details, missing fields like `admin-status` and `oper-status`. You need the full operational status for each interface. What should you do to obtain the complete data?

Accepted Answer

Remove the `terse=True` argument from the RPC call to retrieve the full interface information.. The `terse` argument is a common RPC option that reduces output size by omitting detailed fields. For complete operational status, it must be omitted. The other options either retrieve the wrong type of data or do not affect the output completeness. Removing `terse=True` directly addresses the missing fields.

Answer

Use the `get_config` method with `config_format='set'` to retrieve the interface configuration and infer the operational status.

Answer

Set the `normalize=True` parameter in the `Device` object to ensure all fields are returned.

Answer

Call `get_interface_information` with `interface_name='all'` to retrieve details for every interface including all status fields.

Question 9

You are developing a Python script using PyEZ to load a configuration onto a Junos device. You need to ensure that the configuration is merged with the existing candidate configuration, and that the load operation does not perform a commit check automatically. Which method should you use to load the configuration from a file?

Accepted Answer

Use `cu.load(path='config.conf', merge=True, check=False)`. The `load` method of the PyEZ `Config` object supports `merge` and `check` parameters. To merge without a commit check, use `merge=True` and `check=False`. The other options either use incorrect parameter names, perform an overwrite, or enable the check. Only the combination of merge and check=False achieves the desired behavior.

Answer

Use `cu.load(path='config.conf', overwrite=True, check=False)`

Answer

Use `cu.load(path='config.conf', merge=True, commit_check=True)`

Answer

Use `cu.load(path='config.conf', action='merge', verify=False)`

Question 10

You are writing a PyEZ script that must connect to a Junos device and run several RPCs, but you need the connection to automatically recover if the NETCONF session drops during a long-running task. Which PyEZ connection parameter should you configure to enable this behavior?

Accepted Answer

Set `auto_probe=30` in the `Device` constructor to periodically verify the session and reconnect if needed.. The `auto_probe` parameter in the PyEZ `Device` constructor enables automatic session health checks at a specified interval. When set to a non-zero value, PyEZ periodically probes the NETCONF session and reconnects if it has dropped, which is essential for long-running automation tasks that must survive transient network issues. Other parameters like `port` or context managers do not provide this recovery capability.

Answer

Pass `auto_probe=0` to the `Device` constructor to disable session probing.

Answer

Set `port=22` in the `Device` constructor to use SSH instead of NETCONF.

Answer

Use the `Device` context manager (`with Device(...) as dev:`) to ensure the session is closed properly.

Question 11

You are writing a PyEZ script to retrieve the configured hostname from a Junos device. You want to use the simplest method that returns the hostname as a string without parsing XML manually. Which PyEZ feature should you use?

Accepted Answer

Access `dev.facts['hostname']` after opening the device connection.. PyEZ automatically populates a dictionary of facts when the device connection is established. The `dev.facts` dictionary includes common values such as `hostname`, `model`, `version`, and `serialnumber`. Accessing `dev.facts['hostname']` is the simplest and most direct way to obtain the configured hostname as a string, avoiding manual XML parsing or additional RPC calls.

Answer

Instantiate a `Table` and `View` for the system configuration and extract the hostname field.

Answer

Use `dev.rpc.get_software_information()` and extract the hostname from the response.

Answer

Call `dev.rpc.get_config()` and parse the XML response for the hostname element.

Question 12

You are developing a PyEZ script that loads a configuration snippet onto a Junos device. You want to ensure the configuration is merged with the existing candidate configuration and then committed. Which sequence of PyEZ methods should you use?

Accepted Answer

`dev.load_config()` then `dev.commit()`. The PyEZ `load_config()` method loads a configuration snippet into the candidate configuration, merging it with existing configuration by default. Calling `commit()` then activates the candidate configuration on the device. This two-step sequence is the standard way to apply configuration changes with PyEZ, ensuring that the snippet is merged and committed as required.

Answer

`dev.load_config()` then `dev.commit_check()` then `dev.commit()`

Answer

`dev.load()` then `dev.commit()`

Answer

`dev.load_config(merge=False)` then `dev.commit()`

Question 13

You are writing a PyEZ script that must retrieve interface statistics from a Junos device. You want to use a predefined PyEZ Table to avoid writing custom parsing logic. Which predefined Table should you use to get operational status and statistics for all interfaces?

Accepted Answer

`InterfaceTable`. PyEZ includes predefined Tables that simplify retrieving operational data. `InterfaceTable` is the standard Table for interface information, providing operational status, statistics, and configuration attributes for all interfaces. It abstracts the underlying XML RPCs and returns a structured dictionary, making it ideal for scripts that need interface statistics without custom parsing.

Answer

`ConfigTable`

Answer

`PhyPortTable`

Answer

`EthPortTable`

Question 14

You are writing a PyEZ script that needs to handle exceptions when connecting to a Junos device and executing RPCs. Which TWO exceptions are raised by PyEZ when authentication fails or when the device is unreachable? (Choose two.)

Accepted Answer

`ConnectTimeoutError`. PyEZ defines a set of exceptions for connection-related failures. `ConnectAuthError` is raised when authentication fails, and `ConnectTimeoutError` is raised when the connection attempt times out due to an unreachable device or network issue. These two exceptions directly address the scenarios of authentication failure and unreachability, making them the correct choices.

Answer

`RpcError`

Answer

`PermissionError`

Answer

`ConfigError`

Question 15

You are developing a Python script using Junos PyEZ to retrieve and process operational data. You need to handle exceptions that may occur during device interaction. Which two exceptions are raised by PyEZ when a connection or authentication issue occurs? (Choose two.)

Accepted Answer

ConnectError. PyEZ raises ConnectError for general connection failures and AuthError for authentication failures. AuthError is a subclass of ConnectError, so catching ConnectError will also catch AuthError. These exceptions are essential for robust error handling in automation scripts that interact with Junos devices.

Answer

RpcError

Answer

ConfigError

Answer

TimeoutError