AD0-E722 Practice Questions

According to the Adobe Commerce documentation, to extend an existing GraphQL interface, the

keyword extend must be used before the interface name. This indicates that the new declaration is

adding or modifying fields to the existing interface, rather than redefining it. If the keyword extend is

omitted, the new declaration will be ignored and the original interface will be used. In this case, the

Architect wants to change the type of the my_attribute field in the ProductInterface interface, which

is already declared in the Magento.CatalogGraphQl module. Therefore, the Architect should use the

keyword extend before declaring the ProductInterface interface in the schema.graphqls file of the

custom module. This will allow the Architect to override the type of the my_attribute field from Int

to MyAttributeType.

Reference:

Extend existing schema | Adobe Commerce Developer Guide

Schema language with GraphQL | Adobe Commerce

The magento-vars.php file is used to set the website or store view based on the HTTP host, but it

does not affect GraphQL requests. GraphQL requests are handled by a separate controller that does

not use the magento-vars.php file. Instead, GraphQL requests use the default store view of the

default website, unless a store header or store cookie is provided in the request. The store header or

cookie should contain the store code of the desired store view. For example, to query data from

website_two,

the

request

should

include

a

header

like store:

store_two or

a

cookie

like store=store_two12. Reference:

GraphQL overview | Adobe Commerce 2.4 User Guide - Magento

How to set up multiple websites with Magento 2 - Mageplaza

The carrier model class can implement caching methods to store and retrieve the quotes from the

API based on the request parameters. This can reduce the number of API calls and improve the

performance of the shipping rate calculation. The _setCachedQuotes() method can save the

response from the API to a cache storage, and the _getCachedQuotes() method can check if there is

a cached response for the current request and return it if it exists. Reference: Caching in carrier

model, Carrier model interface

Option A is correct because enabling asynchronous indexing can improve the checkout performance

by reducing the database load and avoiding locking issues. Asynchronous indexing allows the

indexers

to

run

in

the

background

without

affecting

the

frontend

operations. The

command bin/magento config:set dev/grid/async_indexing 1 can be used to enable this option in the

production mode1.

Option C is correct because creating a new database and splitting the sales tables can also improve

the checkout performance by distributing the database load and avoiding contention. Splitting the

database allows the checkout and order management operations to use a separate master database

from the rest of the Magento application tables. The command bin/magento setup:db-schema:split-

sales --host="" --dbname="" --username=""

--password="" can be used to configure this feature2.

Option B is incorrect because enabling asynchronous email notifications does not affect the checkout

performance directly. Asynchronous email notifications allow the order confirmation emails to be

sent in batches by a cron job instead of immediately after placing an order. This option can reduce

the server load and improve the customer experience, but it does not impact the checkout process

itself3.

Option D is incorrect because there is no such deploy mode as siege in Magento 2. The available

deploy modes are default, developer, and production. Changing the deploy mode can affect the

performance, caching, and error handling of the Magento application, but it does not directly affect

the checkout performance4.

Option E is incorrect because there is no such admin panel setting as multithreaded checkout

processing in Magento 2. The number of PHP threads used for checkout is determined by the web

server configuration and the PHP-FPM settings, not by the Magento application settings. Increasing

the number of PHP threads may improve the checkout performance, but it also requires more server

resources and may cause other issues5.

Reference:

1: Asynchronous indexing | Adobe Commerce Developer Guide

2: Split database performance solution | Adobe Commerce Developer Guide

3: Sales Emails | Adobe Commerce User Guide

4: Set up Magento modes | Adobe Commerce Developer Guide

5: PHP-FPM configuration settings | Adobe Commerce Developer Guide

The issue here is that the gather_reporting_data job is running for a long time and blocking the

sitemap_generate job from running. The solution is to create a new cron group for the reporting job

and specify i so that the reporting job runs in a

separate

process

and

does

not

block

the

sitemap_generate

job. Reference:

https://experienceleague.adobe.com/docs/commerce-cloud-service/userguide/architecture/starter-architecture.html?lang=en#cron-groups-and-processes

According to the Adobe Commerce documentation, to create a new xml configuration file, the

Architect needs to create a Data class and a Reader class for the custom module. The Data class is

responsible for storing and retrieving the configuration data from the cache or the Reader class. The

Data class should implement the “\Magento\Framework\Config\Data” interface or extend the

“\Magento\Framework\Config\Data” class. The Reader class is responsible for reading and validating

the xml configuration files from the file system. The Reader class should implement the

'\Magento\Framework\Config\Reader\Filesystem"

interface

or

extend

the

'\Magento\Framework\Config\Reader\Filesystem" class. The Architect also needs to declare the

Data class and the Reader class in the di.xml file of the custom module, and specify the name of the

xml configuration file, the converter class, and the schema locator class for the Reader class.

Reference:

Configuration types | Adobe Commerce - Experience League

Create configuration types | Adobe Commerce - Experience League

Option B is a valid solution because creating a new HTTP Context variable can allow for

differentiating the public content cache for users who belong to a B2B company account. The HTTP

Context variable can be used to modify the output of the header block accordingly, without affecting

the performance or scalability of the site1

Option D is also a valid solution because creating a new custom condition for customer segments can

enable targeting users who are part of a B2B company account. The customer segment can be used

to modify the output of the header block accordingly, using layout updates or dynamic blocks. This

solution can also leverage the existing customer segment functionality and avoid custom coding2

Option A is not a valid solution because switching the theme based on a virtual type can cause

performance issues and increase the complexity of the site maintenance. Moreover, switching the

theme can affect the entire site appearance, not just the header block3

Option C is not a valid solution because using the customer session data directly to modify the output

of the header block can prevent the public content cache from working properly. The customer

session data is private and cannot be cached, so this solution can negatively impact the performance

and scalability of the site4

Option E is not a valid solution because checking if the current user is part of a B2B company within a

block class can also prevent the public content cache from working properly. The block class logic is

executed on every request, so this solution can negatively impact the performance and scalability of

the site5

Reference:

1:

https://experienceleague.adobe.com/docs/commerce-cloud-service/userguide/architecture/starter-architecture.html?lang=en#http-context 2:

https://experienceleague.adobe.com/docs/commerce-cloud-service/userguide/marketing/customer-segments.html?lang=en 3:

https://experienceleague.adobe.com/docs/commerce-cloud-service/userguide/design/themes.html?lang=en 4: https://experienceleague.adobe.com/docs/commerce-cloud-

service/user-guide/architecture/starter-architecture.html?lang=en#private-content 5:

https://experienceleague.adobe.com/docs/commerce-cloud-service/userguide/architecture/starter-architecture.html?lang=en#public-content

The issue here is that the Approval Rules tab does not appear in the Company section in the

Customer Account Menu when the Architect logs in using the Company Administrator account. This

is because the Approval Rules feature requires two settings to be enabled: the Purchase Orders

feature and the Purchase Order payment method. The solution is to set ‘Enable Purchase Orders’ in

the B2B Admin to TRUE and make sure that the ‘Purchase Order’ payment method is active. This will

allow the Architect to create and manage Approval Rules for orders.

Reference:

https://experienceleague.adobe.com/docs/commerce-admin/b2b/purchaseorders/account-dashboard-approval-rules.html?lang=en#account-

dashboard1 https://experienceleague.adobe.com/docs/commerce-admin/b2b/purchaseorders/purchase-order-payment-method.html?lang=en#payment-method2

:

The issue is being caused by the high coupling between objects (CBO) value of the class

MyService. CBO is a metric that measures the number of classes that are coupled to a given class,

either by method calls, property or parameter

, inheritance, or constants1. A high CBO

value indicates that the class is too tightly coupled with other classes, which makes it more difficult

to maintain, test, and reuse2. To reduce the CBO value, the Architect should introduce a new class

that encapsulates the five scalar parameters that configure the behavior of MyService. This way, the

constructor of MyService will only have one parameter of the new class type, instead of five scalar

parameters. This will also make the code more readable and maintainable, as the new class can

provide methods to access and manipulate the configuration data. The constants referencing other

classes should not be consolidated into a string representation, as this would not reduce the CBO

value and would make the code less clear and type-safe3. The number of different classes and

interfaces referenced anywhere inside the class is not relevant for the CBO metric, as it only counts

the classes that are coupled to the given class1. Reference: CBO coupling between object, Coupling

Between Object classes (CBO), Cohesion and coupling of an object in OO programming