AD0-E722 Dumps for Pass Guaranteed - Pass AD0-E722 Exam 2024
AD0-E722 Exam Dumps - Try Best AD0-E722 Exam Questions from Training Expert Prep4away
Adobe AD0-E722 Exam Syllabus Topics:
| Topic | Details |
|---|---|
| Topic 1 |
|
| Topic 2 |
|
| Topic 3 |
|
| Topic 4 |
|
| Topic 5 |
|
NEW QUESTION # 21
An Architect needs to create an additional regional UK website with its own website currency set to GBP in Adobe Commerce. An existing US website is using USD as a default base and website currency.
After the first week of sales in the new UK website, an administrator notices that all sales totals in Sales Orders report show £0.00.
How should this issue be resolved?
- A. Refresh Lifetime Statistics for "Total Invoiced'.
- B. Make sure that orders are shipped and not left in processing state.
- C. Configure currency rates for GBP and USD, so they are not empty.
Answer: C
Explanation:
Explanation
The issue here is that the sales totals in Sales Orders report show £0.00 for the new UK website. This is because the currency rates for GBP and USD are not configured, so the system cannot convert the order amounts from GBP to USD. The solution is to configure the currency rates for GBP and USD, so they are not empty. This will allow the system to calculate the sales totals in USD for the report. References:
https://experienceleague.adobe.com/docs/commerce-admin/stores-sales/site-store/currency/currency-update.html
NEW QUESTION # 22
An Architect agrees to improve company coding standards and discourage using Helper classes in the code by introducing a new check with PHPCS.
The Architect creates the following:
* A new composer package under the AwesomeAgency\CodingStandard\ namespace
* The ruleset. xml file extending the Magento 2 Coding Standard
What should the Architect do to implement the new code rule?
- A.
- B.
- C.
Answer: A
Explanation:
Explanation
Option C is correct because adjusting the ruleset.xml file with the new rule is the simplest and most effective way to implement the new code rule. The ruleset.xml file defines the coding standards that are applied by PHP_CodeSniffer. By extending the Magento 2 Coding Standard and adding a new rule, the Architect can customize the code analysis and enforce the company coding standards. The new rule can use the Magento2.Namespaces.ForbiddenNamespaces sniff to check for any usage of Helper classes in the code and report them as errors or warnings1.
Option A is incorrect because creating a new composer package under the AwesomeAgency\CodingStandard\ namespace is not enough to implement the new code rule. The composer package is just a way to distribute and install the coding standard, but it does not define the rules themselves. The Architect still needs to create a ruleset.xml file and register it with PHP_CodeSniffer2.
Option B is incorrect because creating a new class
\AwesomeAgency\CodingStandard\Ruleset\ForbiddenNamespaces and specifying the rule inside the process method is unnecessary and complicated. The Architect does not need to create a new class or a new sniff for this rule, as there is already an existing sniff in the Magento 2 Coding Standard that can be used for this purpose. The Magento2.Namespaces.ForbiddenNamespaces sniff can be configured with an include-pattern element to specify which namespaces are forbidden1.
References:
1: Magento 2 Coding Standards | Adobe Commerce Developer Guide
2: How to create a custom coding standard | PHP_CodeSniffer Documentation
NEW QUESTION # 23
A third-party company needs to create an application that will integrate the Adobe Commerce system to get orders data for reporting. The integration needs access to the GET /Vl/orders endpoint. It will call this endpoint automatically every hour around the clock. The merchant wants the ability to restrict or extend access to resources as well as to revoke the access using Admin Panel.
Which type of authentication available in Adobe Commerce should be used and implemented in a third-party system for this integration?
- A. Use token-based authentication to obtain the Admin Token. The third-party system will utilize the REST endpoint using the admin username and password to get the Admin Token, which will be used as the Bearer Token to authorize.
- B. Use OAuth-based authentication to provide access to system resources. Integration will be registered by the merchant in the admin panel with an OAuth handshake during activation. The third-party system should follow OAuth protocol to authorize.
- C. Use token-based authentication to obtain an integration Token, integration will be created and activated in the admin panel using default integration token settings to get access to the token, which will be used as the Bearer Token to authorize.
Answer: B
Explanation:
Explanation
According to the Adobe Commerce documentation, OAuth-based authentication is the recommended method for integrations that need access to system resources, such as orders, customers, products, etc. OAuth-based authentication allows the merchant to control the access level and scope of the integration, as well as to revoke the access at any time using the admin panel. OAuth-based authentication also requires an OAuth handshake between the integration and the Adobe Commerce system during activation, which ensures a secure exchange of tokens and keys. The third-party system should follow the OAuth protocol to obtain and refresh the access token, which will be used as the Bearer Token to authorize the REST API calls.
References:
Authentication | Adobe Commerce Developer Guide
OAuth-based authentication | Adobe Commerce Developer Guide
NEW QUESTION # 24
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. Change the can_capture attribute for the payment method under config.xml to be
<can_capture>0</can_capture> - B. Add a plugin before the $invoice->capture() and change Its input to prevent the call of the
$Payment->capture() - C. Declare a capture Command with type Magento\Payment\Gateway\Command\NullCommand for the payment method CommandPool in di.xml
Answer: C
Explanation:
Explanation
Option C is the correct solution because declaring a capture command with type Magento\Payment\Gateway\Command\NullCommand for the payment method command pool in di.xml will prevent the default capture logic from being executed. The NullCommand class is a dummy implementation of the CommandInterface that does nothing. This way, the payment capture will be handled by the PSP webhook, and the invoice will be created accordingly12 Option A is not a correct solution because adding a plugin before the $invoice->capture() and changing its input to prevent the call of the $payment->capture() will require modifying the core Magento code, which is not recommended. Moreover, this solution will affect all payment methods that use the invoice capture logic, not just the monthly installments payment extension3 Option B is not a correct solution because changing the can_capture attribute for the payment method under config.xml to be <can_capture>0</can_capture> will disable the capture functionality for the payment method entirely. This means that the invoice cannot be created or captured, even by the PSP webhook4 References:
1:
https://experienceleague.adobe.com/docs/commerce-cloud-service/user-guide/payments-integrations/payment-ga
https://github.com/magento/magento2/blob/2.4-develop/app/code/Magento/Payment/Gateway/Command/NullCo
https://experienceleague.adobe.com/docs/commerce-cloud-service/user-guide/customization/best-practices.html?
https://experienceleague.adobe.com/docs/commerce-cloud-service/user-guide/payments-integrations/payment-ga
NEW QUESTION # 25
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.collecLtotals.before'' and add the custom tax to the quote
- B. Declare a new total collector in "etc/sales.xmr in a custom module
- C. Write a before plugin to \Magento\Quote\Model\QuoteManagement::placeOrder() and add the custom tax to the quote
Answer: B
Explanation:
Explanation
According to the Adobe Commerce documentation, the best way to add a custom tax calculation to all orders is to declare a new total collector in the "etc/sales.xml" file of a custom module. This way, the custom tax logic can be implemented in a separate class that extends the
\Magento\Quote\Model\Quote\Address\Total\AbstractTotal class and overrides the collect() and fetch() methods. The collect() method is responsible for calculating the tax amount and adding it to the quote address, while the fetch() method is responsible for displaying the tax amount in the cart and checkout pages. The new total collector can be assigned to any area of the order totals, such as before or after the subtotal, shipping, or grand total.
References:
Customizing order totals
How to add custom fee or discount to order totals in Magento 2
NEW QUESTION # 26
An Adobe Commerce Architect needs to ensure zero downtime during the deployment process of Adobe Commerce on-premises. Which two steps should the Architect follow? (Choose two.)
- A. Enable Config flag Under deployement/blue_green/enabled
- B. Enable Config flag Under developer/zero_down_time/enabled
- C. Run bin/magento setup:upgrade --dry-run=true to upgrade database
- D. Run bin/magento setup:upgrade - -keep-generated to Upgrade database
- E. Run bin/magento setup:upgrad --convert-old-scripts-true to Upgrade database
Answer: A,D
Explanation:
Explanation
Option A is correct because enabling the config flag under deployment/blue_green/enabled is one of the steps to ensure zero downtime during the deployment process of Magento 2 on-premises. This flag enables the blue-green deployment feature, which allows deploying a new version of the Magento application to a separate environment (blue) without affecting the current live environment (green). Once the new version is ready, the traffic can be switched from green to blue with minimal or no downtime1.
Option C is correct because running bin/magento setup:upgrade --keep-generated is another step to ensure zero downtime during the deployment process of Magento 2 on-premises. This command updates the database schema and data without deleting the generated code and static view files. This way, the Magento application can still serve requests from the cache while the database is being upgraded2.
Option B is incorrect because running bin/magento setup:upgrade --dry-run=true does not upgrade the database, but only checks if there are any errors or conflicts in the database schema or data. This command can be used for testing purposes, but it does not affect the deployment process or the downtime3.
Option D is incorrect because there is no such option as --convert-old-scripts-true for the bin/magento setup:upgrade command. This option does not exist in Magento 2 and does not have any effect on the deployment process or the downtime.
Option E is incorrect because there is no such config flag as developer/zero_down_time/enabled in Magento 2. This flag does not exist in Magento 2 and does not have any effect on the deployment process or the downtime.
References:
1: Blue-green deployment | Adobe Commerce Developer Guide
2: Deploy Magento to production | Adobe Commerce Developer Guide
3: Command-line installation options | Adobe Commerce Developer Guide
NEW QUESTION # 27
An Adobe Commerce Architect is setting up a Development environment for an on-premises project that will be used for developers to specifically test functionality, not performance, before being passed to the Testing team.
The Magento application must run with the following requirements:
1. Errors should be logged and hidden from the user
2. Cache mode can only be changed from Command Line
3. Static files should be created dynamically and then cached
Which Application Mode is required to achieve this?
- A. Developer Mode
- B. Default Mode
- C. Production Mode
Answer: A
Explanation:
Explanation
Developer mode is the best option for setting up a development environment for testing functionality, not performance, before being passed to the testing team. In developer mode:
Errors are logged and hidden from the user. This ensures that the user does not see any uncaught exceptions or debugging information, but the developers can still access them from the log files.
Cache mode can only be changed from command line. This prevents any accidental or unauthorized changes to the cache settings from the admin panel or other sources.
Static files are created dynamically and then cached. This allows the developers to see the latest changes to the static files without having to run the static content deployment command every time. The static files are also cached for faster loading.
References:
https://experienceleague.adobe.com/docs/commerce-operations/configuration-guide/setup/application-modes.htm
NEW QUESTION # 28
An existing Adobe Commerce website is moving to a headless implementation.
The existing website features an "All Brands'' page, as well as individual pages for each brand. All brand-related pages are cached in Varnish using tags in the same manner as products and categories.
Two new GraphQL queries have been created to make this information available to the frontend for the new headless implementation:
During testing, the queries sometimes return out-of-date information. How should this problem be solved while maintaining performance?
- A. Specify a @cacgecacheable(cacheable: false) directive for each GraphQL query, making sure that the data returned is not cached, and is up to date
- B. 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.
- C. 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
Answer: C
Explanation:
Explanation
This solution ensures that the data returned by the GraphQL queries is up to date, while also maintaining performance. By specifying a $cache(cacheidentity: Path\To\identityclass) directive for each GraphQL query, the relevant brands and associated products will be added as cache tags.
NEW QUESTION # 29
An Adobe Commerce Architect is supporting deployment and building tools for on-premises Adobe Commerce projects. The tool is executing build scripts on a centralized server and using an SSH connection to deploy to project servers.
A client reports that users cannot work with Admin Panel because the site breaks every time they change interface locale.
Considering maintainability, which solution should the Architect implement?
- A. Adjust the tools build script and specify required locales during *setup:static-content:deploy' command
- B. Edit project env.php file, configure 'adminJocales_for_build' value, and specify all required locales
- C. Modify project config.php file, configure 'admin_locales_for_deploy' value, and specify all required locales
Answer: A
Explanation:
Explanation
The issue here is that the site breaks every time the users change interface locale in the Admin Panel. This is because the static content for the different locales is not generated during the deployment process. The solution is to adjust the tools build script and specify required locales during *setup:static-content:deploy' command. This will ensure that the static content for all the needed locales is generated and deployed to the project servers. References:
https://experienceleague.adobe.com/docs/commerce-cloud-service/user-guide/develop/deploy/static-content.htm
NEW QUESTION # 30
The development of an Adobe Commerce website is complete. The website is ready to be rolled out on the production environment.
An Architect designed the system to run in a distributed architecture made up of multiple backend webservers that process requests behind a Load Balancer.
After deploying the system and accessing the website for the first time, users cannot access the Customer Dashboard after logging in. The website keeps redirecting users to the sign-in page even though the users have successfully logged in The Architect determines that the session is not being saved properly.
In the "app/etc/env.php", the session is configured as follows:
What should the Architect do to correct this issue?
- A. Utilize the Remote Storage module to synchronize sessions between the servers
- B. Update the session host value to a shared Redis instance
- C. increase the session size with the command config:set system/security/max_session_size_admin
Answer: B
Explanation:
Explanation
Option A is correct because updating the session host value to a shared Redis instance in the
"app/etc/env.php" file will allow the session to be saved properly and prevent users from being redirected to the sign-in page after logging in. Redis is a fast and reliable in-memory data store that can be used for session storage in Magento 2. By using a shared Redis instance, the session data can be accessed by any of the backend web servers behind the load balancer, regardless of which server handled the initial request. This ensures that the user's session is maintained and consistent across different servers1.
Option B is incorrect because increasing the session size with the command config:set system/security/max_session_size_admin will not solve the issue of session not being saved properly.
This command only affects the admin session size limit, not the customer session size limit. Moreover, this command does not address the root causeof the issue, which is that the session data is not shared among the backend web servers2.
Option C is incorrect because utilizing the Remote Storage module to synchronize sessions between the servers is not a viable solution for this issue. The Remote Storage module is a feature of Magento Commerce Cloud that allows storing media files and other static content on a remote storage service such as AWS S3 or Azure Blob Storage. This module does not support synchronizing sessions between servers, as sessions are dynamic and transient data that need to be stored in a fast and accessible data store such as Redis3.
References:
1: Use Redis for session storage | Adobe Commerce Developer Guide
2: Security | Adobe Commerce User Guide
3: Remote storage | Adobe Commerce Developer Guide
NEW QUESTION # 31
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. Integrity constraints were dropped after upgrading to the latest version, and the integrity checks were missed.
- B. Magento framework uses INSERT on DUPLICATE, which leads to reaching the max limit of the increment of the column.
- C. EAV attribute import uses REPLACE, which leads to reaching the max limit of the increment of the column
Answer: C
Explanation:
Explanation
EAV attribute import uses the REPLACE statement, which deletes and inserts a new row with the same primary key value. This causes the auto-increment column to increase by one for each row, even if the row already exists. If the auto-increment column reaches its maximum value, which is 2147483647 for a signed INT, then any further REPLACE statement will fail with an integrity constraint violation error. References:
EAV and extension attributes | Magento 2 Developer Documentation
GitHub - techdivision/import-attribute: This library provides the functionality for the Magento 2 import of EAV attributes Data integrity in JSON (B) when replacing EAV - Stack Overflow
NEW QUESTION # 32
An Adobe Commerce Architect needs to create a new customer segment condition to enable admins to specify an Average sales amount' condition for certain segments.
The Architect develops the custom condition under
Vendor\Module\Model\Segment\Condition\AverageSalesAmount with all of its requirements:
During testing, the following error appears:
What should the Architect do to fix the problem?
- A.
- B.
- C.
Answer: A
Explanation:
Explanation
The error is caused by the missing class declaration for the custom condition class. According to the Adobe Commerce documentation, to create a custom customer segment condition, the class must extend the
\Magento\CustomerSegment\Model\Condition\AbstractCondition class and implement the
\Magento\CustomerSegment\Model\Condition\Combine\Interface interface. The class must also declare its name, label, value type, and attribute code properties. Option B is the only option that correctly declares the class with the required properties and inheritance. Option A and Option C are incorrect because they do not extend the AbstractCondition class or implement the CombineInterface interface, and they do not declare the name, label, value type, or attribute code properties.
References:
Create a customer segment condition | Adobe Commerce Developer Guide
AbstractCondition | Adobe Commerce Developer Guide
NEW QUESTION # 33
While reviewing a newly developed pull request that refactors multiple custom payment methods, the Architect notices multiple classes that depend on \Magento\Framework\Encryption\EncryptorInterface to decrypt credentials for sensitive data. The code that is commonly repeated is as follows:
The Architect needs to recommend an optimal solution to avoid redundant dependency and duplicate code among the methods. Which solution should the Architect recommend?
- A. Replace all Vendor\PaymentModule\Gateway\Config\Config ClaSSeS With virtualType Of Magento\Payiaent\Gateway\Conf ig\Conf ig and Set <user_secret backend_Model="Magento\Config\Model\Config\Backend\Encrypted" /> Under config.xml
- B. Create a common config service class vendor\Pay-ient\Gateway\conf ig\conf ig under Vendor.Payment and use it as a parent class for all of the Vendor\PayimentModule\Gateway\Conf ig\Conf ig ClaSSeS and remove $scopeConf ig and Sencryptor dependencies
- C. Add a plugin after the getvalue method of $scopeConfig, remove the $encryptor from dependency and use it in the plugin to decrypt the value if the config name is user.secret'
Answer: A
Explanation:
Explanation
The Architect should recommend replacing all Vendor\PaymentModule\Gateway\Config\Config Classes with virtualType of Magento\Payment\Gateway\Config\Config and setting <user_secret backend_Model="Magento\Config\Model\Config\Backend\Encrypted" /> under config.xml. This will avoid redundant dependency and duplicate code among the methods. The virtualType of Magento\Payment\Gateway\Config\Config will inherit the functionality of the base class and allow the customization of the constructor arguments, such as the pathPattern and valueHandlerPool. The backend_Model attribute of the user_secret field will specify that the value of this field should be encrypted and decrypted by the Magento\Config\Model\Config\Backend\Encrypted class, which implements the
\Magento\Framework\App\Config\ValueInterface interface and uses the
\Magento\Framework\Encryption\EncryptorInterfaceinternally12. This way, the payment modules do not need to depend on the \Magento\Framework\Encryption\EncryptorInterface or the
\Magento\Framework\App\Config\ScopeConfigInterface directly, and can use the getValue method of the Magento\Payment\Gateway\Config\Config class to get the decrypted value of the user_secret field3.
References:
How to encrypt system configuration fields in Magento 2 - Mageplaza
Magento 2: How to Encrypt/Decrypt System Configuration Fields - Webkul Blog Magento 2: How to create custom payment method - BelVG Blog
NEW QUESTION # 34
An Adobe Commerce store owner sets up a custom customer attribute "my.attribute".
An Architect needs to display additional content on the home page, which should display only to Customers with "my.attribute" of a certain value and be the same content for all of them. The website is running Full Page Cache.
With simplicity in mind, which two steps should the Architect take to implement these requirements? (Choose two.)
- A. Add a new context value of "my_attribute" to Magento\Framework\App\Http\Context
- B. Create a Customer Segment and use 'my.attribute' in the conditions
- C. Use customer-data JS library to retrieve "my.attribute" value
- D. Add a dynamic block with the content to the Home Page
- E. Add a custom block and a pHTML template with the content to the cmsjndexjndex.xml layout
Answer: A,D
Explanation:
Explanation
To display additional content on the home page based on a custom customer attribute, the Architect needs to do the following steps:
Add a new context value of "my_attribute" to Magento\Framework\App\Http\Context. This will allow the Full Page Cache to generate different versions of the page for customers with different values of
"my.attribute". The context value can be set using a plugin on the Magento\Customer\Model\Context class.
Add a dynamic block with the content to the Home Page. A dynamic block is a type of content block that can be configured to display only to specific customer segments or conditions. The Architect can use the 'my.attribute' in the conditions of the dynamic block and assign it to the Home Page in the Content > Blocks section of the Admin Panel. References:
Private content | Magento 2 Developer Documentation
Dynamic Blocks | Adobe Commerce 2.3 User Guide - Magento
NEW QUESTION # 35
An Architect is configuring the preload.keys for Redis on an Adobe Commerce on-premise instance.
The Architect discovers that the following cache keys are loaded on each frontend request:
EAV_ENTITY_TYPES, GLOBAL_PLUGIN_LIST, DB_IS_UP_TO_DATE, SYSTEM_DEFAULT.
* The id_prefix of the frontend => page_cache is set to 063_.
* The id_pref ix of frontend => default is set to 762_.
* The Architect has enabled and configured Redis L2 caching.
How should the preload.keys be configured?
- A.
- B.
- C.
- D.
Answer: D
Explanation:
Explanation
Option C is correct because it configures the preload.keys correctly for Redis L2 caching on an Adobe Commerce on-premise instance. Redis L2 caching is a feature that allows storing the cache data in both Redis and the local file system. This way, the cache data can be loaded faster from the local storage, while Redis acts as a cache invalidation service. To use Redis L2 caching, the backend option for both frontend => page_cache and frontend => default must be set to Magento\Framework\Cache\Backend\RemoteSynchronizedCache1. To enable the preload feature, which reduces the number of requests to Redis, the preload.keys option must be specified with the cache keys that are loaded on each frontend request. However, unlike Redis L1 caching, the preload.keys must include the suffix :hash to indicate that only the hash values of the cache data are stored in Redis2.
Therefore, the correct configuration for preload.keys is:
<preload_keys' => [ '762_EAV_ENTITY_TYPES:hash', '762_GLOBAL_PLUGIN_LIST:hash',
'762_DB_IS_UP_TO_DATE:hash', '762_SYSTEM_DEFAULT:hash', ],
Option A is incorrect because it configures the preload.keys incorrectly for Redis L2 caching. It uses the id_prefix of frontend => page_cache (063_) instead of frontend => default (762_) for the cache keys.
This will cause a mismatch between the cache keys and the cache data, and result in incorrect or missing cache data. Moreover, it does not include the suffix :hash for the preload.keys, which is required for Redis L2 caching2.
Option B is incorrect because it configures the preload.keys incorrectly for Redis L2 caching. It does not include the suffix :hash for the preload.keys, which is required for Redis L2 caching2. It also uses a wrong cache key (GLOBAL_PLUGIN_LIST) instead of GLOBAL_PLUGIN_LIST.
Option D is incorrect because it configures the preload.keys incorrectly for Redis L2 caching. It uses a wrong id_prefix (162_) instead of frontend => default (762_) for the cache keys. This will cause a mismatch between the cache keys and the cache data, and result in incorrect or missing cache data. It also uses a wrong cache key (EAV_ENTITY_TYPES) instead of EAV_ENTITY_TYPES.
References:
1: Two-level caching | Adobe Commerce Developer Guide
2: Use Redis for default cache | Adobe Commerce Developer Guide
NEW QUESTION # 36
An Architect wants to create an Integration Test that does the following:
* Adds a product using a data fixture
* Executes $this->someLogic->execute($product) on the product
* Checks if the result is true.
$this->someLogic has the correct object assigned in the setup() method.
Product creation and the tested logic must be executed in the context of two different store views with IDs of 3 and 4, which have been created and are available for the test.
How should the Architect meet these requirements?
- A. Create one test class with two test methods. Use the emagentostorecontext 3 annotation in one method and amagentostorecontext 4 in the other one.
- B. Create two test classes with one test method each. Use the @magentoExecuteinstoreContext 3 and
$MagentoExecuteinStoreContext 4 annotations on the class level. - C. Create one test class with one test method. Use the
\Magento\TestFramework\store\ExecuteinstoreContext class once in the fixture and another time in the test.
Answer: C
Explanation:
Explanation
To create an integration test that executes different logic in different store views, the Architect needs to do the following steps:
Create one test class that extends \Magento\TestFramework\TestCase\AbstractController or
\Magento\TestFramework\TestCase\AbstractBackendController, depending on the type of controller being tested1.
Create one test method that uses the @magentoDataFixture annotation to specify the data fixture file that creates the product2.
Use the \Magento\TestFramework\Store\ExecuteInStoreContext class to execute the fixture and the tested logic in different store views. This class has a method called executeInStoreContext, which takes two parameters: the store ID and a callable function. The callable function will be executed in the context of the given store ID, and then the original store ID will be restored3. For example:
PHPAI-generated code. Review and use carefully. More info on FAQ.
public function testSomeLogic()
{
// Get the product from the fixture
$product = $this->getProduct();
// Get the ExecuteInStoreContext instance from the object manager
$executeInStoreContext =
$this->_objectManager->get(\Magento\TestFramework\Store\ExecuteInStoreContext::class);
// Execute the fixture in store view 3
$executeInStoreContext->executeInStoreContext(3, function () use ($product) {
// Do some operations on the product in store view 3
});
// Execute the tested logic in store view 4
$result = $executeInStoreContext->executeInStoreContext(4, function () use ($product) {
// Call the tested logic on the product in store view 4
return $this->someLogic->execute($product);
});
// Assert that the result is true
$this->assertTrue($result);
}
References:
Integration tests | Magento 2 Developer Documentation
Data fixtures | Magento 2 Developer Documentation
Magento\TestFramework\Store\ExecuteInStoreContext | Magento 2 Developer Documentation
NEW QUESTION # 37
......
Latest 100% Passing Guarantee - Brilliant AD0-E722 Exam Questions PDF: https://www.prep4away.com/Adobe-certification/braindumps.AD0-E722.ete.file.html
Practice Examples and Dumps & Tips for 2024 Latest AD0-E722 Valid Tests Dumps: https://drive.google.com/open?id=19cJkOhXCU7GoubuWSaj8OAg3FH9hYYjH