Adobe AD0-E722 Practice Test Questions, Exam Dumps

Practice Exams:

View All

AD0-E722 Adobe Practice Test Questions and Exam Dumps

Question No 1:

A company wants to build an Adobe Commerce website to sell their products to customers in their country. The taxes in their country are highly complex and require customization to Adobe Commerce. An Architect is trying to solve this problem by creating a custom tax calculator that will handle the calculation of taxes for all orders in Adobe Commerce.

Following best practices, how should the Architect add the taxes for all orders?

A. Add a new observer to the event “sales_quote_collect_totals_before” and add the custom tax to the quote
B. Write a before plugin to \Magento\Quote\Model\QuoteManagement::placeOrder() and add the custom tax to the quote
C. Declare a new total collector in “etc/sales.xml” in a custom module

Correct Answer:
C. Declare a new total collector in “etc/sales.xml” in a custom module

Explanation:

When handling custom tax calculations in Adobe Commerce (Magento), following best practices is crucial. The recommended approach is to declare a new total collector within your custom module by specifying it in the etc/sales.xml configuration file.

Option C is correct because Magento provides a specific method for handling custom totals (including taxes) via total collectors. A custom total collector allows you to define a class that calculates the custom tax, and the result is integrated seamlessly with the Magento order processing flow. This method ensures the tax calculations are applied at the correct stage and in the correct order.

Why the other options are not optimal:

A. Add a new observer to the event “sales_quote_collect_totals_before” and add the custom tax to the quote:
While observers can be used to listen to events such as sales_quote_collect_totals_before, this approach can be less maintainable and harder to integrate with other total calculations, such as custom shipping fees, discounts, etc. It is not the most appropriate or scalable solution for handling complex tax calculations.
B. Write a before plugin to \Magento\Quote\Model\QuoteManagement::placeOrder() and add the custom tax to the quote:
A before plugin on placeOrder() would allow you to modify the quote before the order is placed. However, this approach is not ideal for tax calculations because it doesn't follow the clean separation of concerns and can interfere with the normal flow of order processing. It’s more appropriate to use total collectors or other core Magento mechanisms to calculate taxes before finalizing the order.

By declaring a new total collector in etc/sales.xml, the tax calculation logic will be integrated in a way that follows Magento's best practices and ensures that the custom tax logic is properly executed in the context of the full checkout flow.

Question No 2:

A third-party company needs to create an application that will integrate with the Adobe Commerce system to retrieve order data for reporting. The integration needs to access the GET /V1/orders endpoint and will call this endpoint automatically every hour. The merchant wants the ability to manage access, including restricting, extending, or revoking it using the Admin Panel.

Which authentication method should the third-party system implement for this integration?

A. Use token-based authentication to obtain the Admin Token. The third-party system will utilize the admin username and password to obtain the Admin Token, which will be used as a Bearer Token to authorize access.
B. Use token-based authentication to obtain an Integration Token. The integration will be created and activated in the Admin Panel, and the Integration Token will be used as a Bearer Token for authorization.
C. Use OAuth-based authentication to provide access to system resources. The integration will be registered by the merchant in the Admin Panel with an OAuth handshake during activation, and the third-party system should follow the OAuth protocol to authorize access.

Answer: C

Explanation:

A. Use token-based authentication to obtain the Admin Token:

This method is not ideal as it grants the third-party system excessive administrative permissions. It requires the use of the admin username and password, which could lead to security risks and less flexible access management.

B. Use token-based authentication to obtain an Integration Token:

This is a better approach than using an Admin Token, as the Integration Token is specifically created for integrations. However, while it allows for some level of control, it lacks the flexibility and granular permissions provided by OAuth, and token management isn't as dynamic.

C. Use OAuth-based authentication:

This is the recommended solution. OAuth provides a secure and flexible authentication mechanism for third-party integrations. It allows merchants to manage access via the Admin Panel and provides features like token expiration and automatic renewal. OAuth ensures that the third-party system can only access the necessary resources, making it the most secure and manageable option for this use case.

Question No 3:

An Architect is working on a custom module and needs to define a new XML configuration file. The module should be able to read all XML configuration files declared in the system, merge them together, and use their values in a PHP class.

What are the two steps the Architect should take to meet this requirement? (Choose two.)

A. Inject a “reader” dependency for “Magento\Framework\Config\Data” in di.xml
B. Write a plugin for \Magento\Framework\Config\Data::get() and read the custom XML files
C. Create a Data class that implements “\Magento\Framework\Config\Data”
D. Append the custom XML file name in “Magento\Config\Model\Config\Structure\Reader” in di.xml
E. Create a Reader class that implements “\Magento\Framework\Config\Reader\Filesystem”

Answer:

A. Inject a “reader” dependency for “Magento\Framework\Config\Data” in di.xml
D. Append the custom XML file name in “Magento\Config\Model\Config\Structure\Reader” in di.xml

Explanation:

To achieve the desired functionality of reading and merging XML configuration files in Magento, the Architect should follow these two steps:

A. Inject a “reader” dependency for “Magento\Framework\Config\Data” in di.xml
By injecting the Magento\Framework\Config\Data reader dependency into the module’s di.xml, the module gains access to Magento's built-in functionality for reading and processing configuration data. This dependency helps in managing the configuration and allows the module to pull in values from various XML configuration files.
D. Append the custom XML file name in “Magento\Config\Model\Config\Structure\Reader” in di.xml
To ensure that the new XML configuration file is integrated into Magento's configuration system, the XML file name must be appended to the Magento\Config\Model\Config\Structure\Reader in di.xml. This tells Magento to read and merge the custom XML file alongside other configuration files during the system's operation.

Why Other Options Are Incorrect:

B. Write a plugin for \Magento\Framework\Config\Data::get() and read the custom XML files
Writing a plugin for the get() method is unnecessary for reading and merging configuration files. Plugins are typically used to modify the behavior of existing methods, not for processing configuration data.
C. Create a Data class that implements “\Magento\Framework\Config\Data”
While it is possible to implement a custom data class, Magento already provides Magento\Framework\Config\Data for handling configuration files. There's no need to reinvent the wheel unless you require a very specific, custom solution.
E. Create a Reader class that implements “\Magento\Framework\Config\Reader\Filesystem”
Creating a custom reader class might be useful in more complex situations, but it is generally not required in this case. By appending the custom XML file to the Config\Structure\Reader, you can achieve the goal without the need to create a custom reader class.

Question No 4:

An Adobe Commerce Architect creates a stopword for the Italian locale named stopwordsJtJT.csv and changes the stopword directory to the following:
<magento_root>/app/code/CustomVendor/Elasticsearch/etc/stopwords/
What is the correct approach to change the stopwords directory inside the custom module?

A. Add stopwords to the stopwordsDirectory and CustomVendor_Elasticsearch to the stopwordsModule parameter of the \Magento\Elasticsearch\SearchAdapter\Query\Preprocessor\Stopwords class via di.xml
B. Add a new class implementing \Magento\Framework\Setup\Patch\PatchInterface to modify the default Value of elasticsearch\custom\stopwordspath in core_config_data table.
C. Add stopwords to the stopwordsDirectory parameter of the \Magento\Elasticsearch\Model\Adapter\Document\DirectoryBuilder class via stopwords/it.xml and Adobe Commerce will automatically detect the current module.

Answer: C. Add stopwords to the stopwordsDirectory parameter of the \Magento\Elasticsearch\Model\Adapter\Document\DirectoryBuilder class via stopwords/it.xml and Adobe Commerce will automatically detect the current module.

Explanation:

To change the stopwords directory inside a custom module in Adobe Commerce (Magento), the most effective and correct approach is Option C. Let's dive deeper into why this is the best option and explain the other options.

Why Option C is Correct:

Adobe Commerce allows you to customize stopwords for different languages and locales, which helps refine search results by eliminating common, irrelevant words. In a custom module, to define a new directory where stopwords are located, you should use the stopwordsDirectory parameter within the \Magento\Elasticsearch\Model\Adapter\Document\DirectoryBuilder class. This can be done by creating a configuration file (such as stopwords/it.xml) in the custom module directory. The system will automatically detect the module and the new stopword directory settings based on this configuration.

The approach allows you to easily modify the stopwords directory without requiring manual changes to the core configurations or classes. Adobe Commerce is designed to automatically recognize these changes when they are specified in the module's configuration, which streamlines the customization process.

Why the Other Options are Incorrect:

A. Add stopwords to the stopwordsDirectory and CustomVendor_Elasticsearch to the stopwordsModule parameter of the \Magento\Elasticsearch\SearchAdapter\Query\Preprocessor\Stopwords class via di.xml
This option is incorrect because it introduces unnecessary complexity by attempting to modify the \Magento\Elasticsearch\SearchAdapter\Query\Preprocessor\Stopwords class using Dependency Injection (DI) via di.xml. This would involve manually altering the DI configuration, which is not required for setting the stopwords directory in the custom module. Option C is a simpler and more direct approach.
B. Add a new class implementing \Magento\Framework\Setup\Patch\PatchInterface to modify the default Value of elasticsearch\custom\stopwordspath in core_config_data table.
While this option involves modifying the core_config_data table, it's not the correct approach for adjusting the stopwords directory. The PatchInterface method would be used to modify system settings or configurations on a deeper level, but it’s unnecessary in this case. The goal is to modify the stopwords directory within the module itself, and Option C accomplishes this much more directly and effectively.

The most efficient and correct method to change the stopwords directory in a custom Adobe Commerce module is to use the stopwordsDirectory parameter within a configuration file in the custom module, as outlined in Option C. This ensures that Adobe Commerce automatically detects and applies the new stopword settings for the specified locale without modifying core configurations or creating unnecessary custom classes.

Question No 5:

A client has multiple warehouses where orders can be fulfilled. The cost of shipping goods from each warehouse varies by day, due to the number of workers available. The Architect needs to make sure that when an order is shipped, it is shipped from the lowest-cost warehouse that is open.

How should this functionality be implemented?

A. Create a new class as a preference for Magento\InventoryShipping\Plugin\Sales\Shipment\AssignSourceCodeToShipmentPlugin to set the lowest-cost warehouse on a shipment.
B. Create a new class implementing Magento\InventorySourceSelectionApi\Model\SourceSelectionInterface, which returns open warehouses sorted by cost.
C. Create an after plugin on Magento\InventoryDistanceBasedSourceSelection\Model\Algorithms\DistanceBasedAlgorithm to sort Warehouse sources by cost.

Correct Answer: B. Create a new class implementing Magento\InventorySourceSelectionApi\Model\SourceSelectionInterface, which returns open warehouses sorted by cost.

Explanation:

In this scenario, the client needs to ensure that orders are fulfilled from the lowest-cost warehouse that is open. The solution to this problem involves modifying how warehouses are selected for fulfillment, and this can be achieved by implementing a custom source selection mechanism that prioritizes warehouses based on shipping cost.

Key Concepts:

Source Selection: This refers to the process of determining which warehouse or inventory source an order will be fulfilled from.
Magento Inventory System: Magento 2 has a system that manages multiple warehouses (called "inventory sources"), and the InventorySourceSelectionApi is an API that can be extended to customize how the source (warehouse) is selected for fulfilling an order.

Breaking Down the Options:

Option A: Create a new class as a preference for Magento\InventoryShipping\Plugin\Sales\Shipment\AssignSourceCodeToShipmentPlugin to set the lowest-cost warehouse on a shipment.

This approach is not ideal because the AssignSourceCodeToShipmentPlugin plugin is already responsible for assigning a source code to shipments, but it does not have the flexibility to prioritize warehouses by cost. It is better to extend the SourceSelectionInterface to address this specific requirement directly.

Option B: Create a new class implementing Magento\InventorySourceSelectionApi\Model\SourceSelectionInterface, which returns open warehouses sorted by cost.

This is the correct approach. By implementing the SourceSelectionInterface, you can customize the logic that Magento uses to choose a warehouse for fulfillment. In this custom implementation, you can return open warehouses sorted by cost (or other criteria), ensuring that the lowest-cost warehouse is selected. This solution directly addresses the requirement to fulfill orders from the lowest-cost warehouse that is open.

Option C: Create an after plugin on Magento\InventoryDistanceBasedSourceSelection\Model\Algorithms\DistanceBasedAlgorithm to sort Warehouse sources by cost.

While this option suggests modifying the DistanceBasedAlgorithm, which is primarily concerned with selecting warehouses based on proximity, it does not address the specific requirement of sorting warehouses by cost. The distance-based selection algorithm is more focused on physical distance rather than cost, so this option is not suitable for this use case.

The best approach is to implement the Magento\InventorySourceSelectionApi\Model\SourceSelectionInterface and return open warehouses sorted by cost. This approach allows for the flexibility to customize the warehouse selection based on the lowest cost, as required by the client. Therefore, the correct answer is B.

Question No 6:

A merchant is using a unified website that supports native Adobe Commerce B2B and B2C with a single store view.The merchant’s objective is to display the B2B account features, such as negotiable quotes and credit limits, in the header of the site on every page for logged-in users who belong to a B2B company account.Each B2B company possesses its unique shared catalog and customer group, while numerous customer groups for non-B2B customers undergo changes. The merchant insists that this association should not be linked to customer groups.

Which two solutions should the Architect recommend for consideration, taking into account public data and caching? (Choose two.)

A. Create a Virtual Type that switches the theme when a user is part of a B2B company so the output can be modified accordingly in the alternate theme.
B. Create a new HTTP Context variable to allow for separate public content to be cached for users in B2B companies where the output can be modified accordingly.
C. Set whether the current user is part of a B2B company in the customer session and use that data directly to modify the output accordingly.
D. Create a new custom condition for customer segments that allow for choosing whether a user is part of a B2B company and then use this segment to modify the output accordingly.
E. Check if the current user is part of a B2B company within a block class and modify the output accordingly.

Correct Answer:
C. Set whether the current user is part of a B2B company in the customer session and use that data directly to modify the output accordingly.
E. Check if the current user is part of a B2B company within a block class and modify the output accordingly.

Explanation:

The merchant is working with a unified website supporting both B2B and B2C customers, with specific requirements to display B2B account features like negotiable quotes and credit limits for logged-in users associated with B2B company accounts. The merchant wants this to be done without linking to customer groups and needs a solution that is efficient in caching and does not interfere with public data.

The following solutions are recommended:

C. Set whether the current user is part of a B2B company in the customer session and use that data directly to modify the output accordingly.
This is a simple and effective approach where you store information about the B2B company in the customer session. This ensures that every page load for a logged-in B2B user can check the session and display the required B2B-specific content in the header. By using session data, you avoid modifying caching strategies and still provide dynamic content for the user.
E. Check if the current user is part of a B2B company within a block class and modify the output accordingly.
By checking the user status within a block class, you can modify the content of the page for B2B users directly, displaying relevant data like negotiable quotes or credit limits in the header. This is a clean way to implement custom logic without interfering with the caching strategy.

Why the other options are less ideal:

A. Create a Virtual Type that switches the theme when a user is part of a B2B company so the output can be modified accordingly in the alternate theme.
Switching the theme based on user type is not optimal for this scenario. The goal is to show B2B-specific information in the header without affecting the overall layout of the site or requiring theme switching, which could be unnecessarily complex and lead to performance issues.
B. Create a new HTTP Context variable to allow for separate public content to be cached for users in B2B companies where the output can be modified accordingly.
While HTTP Context variables might be useful for handling certain user-specific data, using it for B2B content could complicate caching strategies. It would require managing separate caches for B2B users and could impact the overall performance and scalability of the site.
D. Create a new custom condition for customer segments that allow for choosing whether a user is part of a B2B company and then use this segment to modify the output accordingly.
Customer segments are typically tied to marketing and content personalization, which isn’t ideal for this use case. It might complicate the logic for displaying B2B-specific content and may not be necessary if simpler methods like session data or block class logic suffice.

In summary, the best approach for displaying B2B features efficiently and in a way that works well with caching and public data is to use session-based data (option C) and block class logic (option E) to modify the header dynamically for B2B users.

Question No 7:

An Adobe Commerce Architect needs to customize the workflow of a monthly installments payment extension. The extension is from a partner who is contracted with the default website Payment Service Provider (PSP), which has its own legacy extension (a module using deprecated payment method).The installment payment partner manages only initializing a payment, and then hands the capture to be executed by the PSP. Once the amount is successfully captured, the PSP notifies the website through a webhook. The goal of the webhook is only to create an “invoice” and save the “capture information” to be used later for refund requests through the PSP itself.The Architect needs the most simple solution to capture the requested behavior.

Which solution should the Architect implement?

A. Add a plugin before the $invoice->capture() and change its input to prevent the call of the $payment->capture()
B. Change the can_capture attribute for the payment method under config.xml to be <can_capture>0</can_capture>
C. Declare a capture command with type Magento\Payment\Gateway\Command\NullCommand for the payment method CommandPool in di.xml

Correct Answer: B. Change the can_capture attribute for the payment method under config.xml to be <can_capture>0</can_capture>

Explanation:

The objective of the requirement is to prevent the default behavior of the capture method from executing when the payment is initialized by the partner extension. The PSP is responsible for capturing the payment after it is initialized, so the Magento Commerce system should only record the capture event and create an invoice once the PSP confirms the capture via the webhook.

Here’s an analysis of the available options:

A. Add a plugin before the $invoice->capture() and change its input to prevent the call of the $payment->capture():
This approach involves adding a custom plugin to modify the behavior of the capture method. While this is a viable solution, it involves additional complexity, and using a plugin in this manner may not be the most straightforward approach given the requirements. The solution would involve intercepting the capture process at a lower level, which is not necessary if there is a simpler way to control the capture behavior at a configuration level.
B. Change the can_capture attribute for the payment method under config.xml to be <can_capture>0</can_capture>:
This solution directly addresses the problem by setting the can_capture attribute to 0 in the payment method configuration. By disabling the ability to capture payments through Magento, you ensure that the capture action is not performed by the default Magento behavior. This way, you allow the PSP to handle the capture separately and simply use the webhook to create the invoice once the payment is captured, making it the simplest and most straightforward solution.
C. Declare a capture command with type Magento\Payment\Gateway\Command\NullCommand for the payment method CommandPool in di.xml:
This approach involves creating a custom NullCommand to nullify the capture action. While this could technically work, it requires more customization and involves altering the command pool in di.xml. This solution introduces more complexity than necessary and is not the most optimal solution, especially when the simpler solution of setting can_capture to 0 is available.

Thus, B is the most efficient and minimal solution to meet the requirement. By setting <can_capture>0</can_capture>, Magento is prevented from executing the capture logic, and the PSP can handle the capture process separately, with the webhook handling the invoice creation afterward.

Question No 8:

How should the problem of returning out-of-date information in the GraphQL queries be solved while maintaining performance in the headless implementation?

A. Specify a $cache(cacheable: false) directive for each GraphQL query, making sure that the data returned is not cached, and is up to date
B. Specify a @cache(cacheIdentity: Path\To\IdentityClass) directive for each GraphQL query, corresponding to a class that adds cache tags for relevant brands and associated products
C. Each GraphQL query’s resolver class should inject \Magento\GraphQlCache\Model\CacheableQuery and call setCacheValidity(true) on it as part of the resolver’s resolve function

Answer: B

Explanation:

In a headless Adobe Commerce setup, cache management is essential for performance optimization, especially when dealing with GraphQL queries for dynamic data like brand-related pages. When the website is caching pages in Varnish and issues arise with returning outdated information, the goal is to make sure the data is kept fresh while still benefiting from the performance advantages of caching.

A. Specify a $cache(cacheable: false) directive for each GraphQL query, making sure that the data returned is not cached, and is up to date
Incorrect answer. While setting cacheable: false would indeed prevent caching, it would also negate the performance benefits of caching altogether. Caching is crucial for high performance, and this approach would mean that every query would need to be processed in real time, significantly reducing performance and scalability.
B. Specify a @cache(cacheIdentity: Path\To\IdentityClass) directive for each GraphQL query, corresponding to a class that adds cache tags for relevant brands and associated products
Correct answer. This solution uses the @cache directive, which allows specifying cache identities for GraphQL queries. By tagging the data with specific cache tags (e.g., brand data or product data), this approach ensures that the cache is invalidated or refreshed when relevant data changes. The cache tags help Varnish and other caching systems keep the data current without losing the performance advantages of caching.
C. Each GraphQL query’s resolver class should inject \Magento\GraphQlCache\Model\CacheableQuery and call setCacheValidity(true) on it as part of the resolver’s resolve function
Incorrect answer. This approach focuses on controlling cache validity from within the resolver, but it does not address the need for cache invalidation or managing cache tags related to the changes in brand data. This solution might not be as effective in ensuring the cache is properly invalidated when changes occur to brands or associated products.

The best approach to address this issue while maintaining performance is to use the @cache directive with cache identities to manage cache tags that ensure up-to-date data is served when necessary.

Question No 9:

An Adobe Commerce Architect is investigating a case where some EAV product attributes are no longer updated. The catalog is composed of 20,000 products with 100 attributes each. The product updates are run by recurring Adobe commerce imports that happen multiple times a day. The Architect finds an error in the logs that indicates an integrity constraint while trying to insert row with id 2147483647.

What is causing this error?

A. Magento framework uses INSERT on DUPLICATE, which leads to reaching the max limit of the increment of the column.
B. Integrity constraints were dropped after upgrading to the latest version, and the integrity checks were missed.
C. EAV attribute import uses REPLACE, which leads to reaching the max limit of the increment of the column.

Answer: C

Explanation:

The error message refers to the insertion of a row with ID 2147483647, which is the maximum value of a 32-bit signed integer. In this case, the root cause of the error is the system attempting to insert a new row in the database with an ID that exceeds the maximum allowable value for an auto-incrementing column.

Let’s break down the options and explain why C is correct:

A. Magento framework uses INSERT on DUPLICATE, which leads to reaching the max limit of the increment of the column: This option references the INSERT ON DUPLICATE KEY functionality, which is typically used in SQL to handle duplicates by updating existing rows instead of inserting new ones. However, this doesn’t directly explain the issue of hitting the max value of an auto-increment column. It is unlikely that INSERT ON DUPLICATE would be the cause of the row ID limit being reached.
B. Integrity constraints were dropped after upgrading to the latest version, and the integrity checks were missed: While integrity constraints are important for maintaining data consistency, this scenario is more related to the insertion of rows and the reach of the auto-increment value in a column. The error doesn't suggest that the issue is due to dropped integrity constraints or skipped checks but rather that the system is attempting to insert data that violates the range for the auto-increment value.
C. EAV attribute import uses REPLACE, which leads to reaching the max limit of the increment of the column: This option correctly identifies the problem. The EAV (Entity-Attribute-Value) model is used in Magento to store product attributes. When importing EAV data, REPLACE is commonly used to update records or insert new ones. The problem arises when the ID generated for a new or updated row exceeds the limit of a 32-bit signed integer (2147483647). When the system tries to insert or replace data using a value larger than this, it hits the maximum limit for auto-incrementing columns, causing an error. This issue is especially likely when dealing with a large number of products and attributes, as in this case.

Thus, C is the most accurate answer because it directly addresses the issue of the auto-increment value being exceeded when importing EAV data using the REPLACE statement.

Additional Recommendations:

To resolve the issue, the database schema may need to be adjusted, specifically the auto-increment column for the product and attribute tables. One solution might involve switching to a larger column type for the ID (e.g., using a BIGINT instead of an INT for the auto-increment column). Additionally, reviewing the import process and ensuring that REPLACE is not inadvertently causing this issue would also be beneficial.