Magento Developer Certification Topics Index

  • describe magento codepools
  • describe typical magento module structure
  • how does the framework interact with the various codepools?
  • corresponding sales entity for mage_sales_model_mysql4_setup

1 – Basics
This topic comprises approximately 5% of the exam. Questions are drawn randomly from the
following objectives:
Fundamentals
○ Describe and apply basic principles and processes of Object Oriented
Programming (OOP) and Model-View-Controller (MVC) to build Magento
websites
○ Identify and describe the principles of Event-Driven Architecture (EDA)
Magento is an MVC framework that is developed with an awareness of OOP
principals including classic design patterns and GRASP. Magento’s
implementation of these patterns and principals can at times be unique.
■ What are some of the design patterns implemented in the framework,
and how do they differ from the classic implementation of these
patterns?
■ How are class constructors used in Magento?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage
■ Mage_Core_Model_Config
Magento directory structure
○ Describe the Magento directory structure, including naming conventions, code
pools, and namespaces
○ Describe the Magento module structure
○ Describe/identify the code pools used in Magento
○ Locate templates, layout XML, skins, javascript, and temporary directories
within the Magento directory structure
Magento’s modularity allows for flexibility and helps to organize code in a
common structure. Experienced developers will be familiar with the general
conventions of module structure in Magento. Given the number of files in the
system, preserving module design conventions is essential.
■ What constitutes a namespace and a module?
■ What does the filesystem of a complete theme look like?
■ How does the framework interact with the various codePools?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_App
■ Mage_Core_Model_Config
Configuration XML
○ Create and register a module
○ Specify option in the config file
○ Configure website- and store- scoped values
○ Add different values for different stores
As an XML DOM configuration-based framework, thorough understanding of
how Magento loads and assembles its configuration XML DOM is a core
competency.
■ How does the framework discover active modules and their
configuration?
■ What are the common methods with which the framework accesses its
configuration values and areas?
■ How are per-store configuration values established in the XML DOM?
■ Which class types and files have explicit paths?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Config
■ Mage_Core_Model_Store

Functional and factory class groups
○ Instantiate main Magento objects
○ Get different instances from different places
Appropriate instantiation of most Magento modules’ classes depends on
module configuration.
■ By what process do the factory methods and autoloader enable class
instantiation?
■ Which class types have an entirely configurable path?
■ Which methods of which classes can be used to instantiate Magento
classes?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Config
■ Varien_Autoload
Class overrides in Magento
○ Replace Model, Helper, and Block classes
○ Override a class
One of the useful and oft-used characteristics of the Magento framework is the
ability to change and/or add to existing class functionality via module
configuration.
■ For which class types can individual classes be overridden via
configuration XML?
■ What do class overrides look like in configuration XML?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Config

Event observer
○ Register an Observer
○ Configure an Observer to work in only frontend or backend
○ Configure an Observer to work in both frontend and backend
○ Set up a cron job
○ Identify the function and proper use of automatically available events, including
*_load_after, etc.
Magento’s event-driven architecture provides numerous hooks into most areas
of and processes in the application.
■ What does event observer configuration look like in the configuration
XML?
■ Under which event areas can event observers be declared? How does
this look in the configuration XML?
■ Which classes – when properly declared – have automatically-fired, class-specific events?
■ How are event-relevant objects & data transported into event observers,
and how can they be accessed therein?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_App
■ Mage_Core_Model_App_Area
■ Mage_Core_Model_Config
■ Varien_Event
■ Varien_Event_Collection
■ Varien_Event_Observer
■ Varien_Object
Module conflicts
○ Describe methods for resolving module conflicts.

It is often the case that an installation will include local and/or community
customizations which rely on colliding xpaths in the configuration XML.
■ How do override conflicts manifest themselves in the configuration
XML, and how can they be recognized?
■ What effect does module load order have on module conflicts?
■ What is an alternative to class rewrites?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Config::getGroupedClassname()
Internationalization
○ Describe how to plan for internationalization of a Magento site
○ Describe the use of Magento translate classes and translate files
○ Describe the advantages and disadvantages of using subdomains and
subdirectories in internationalization
Magento offers many options to internationalize and customize stores.
Knowing the limitations and possibilities of each option is key to debugging
translation issues and choosing the best approach to a given task.
■ Which method is used for translating strings, and on which types of
objects is it generally available?
■ In what way does the developer mode influence how Magento handles
translations?
■ How many options exist to add a custom translation for any given
string?
■ Which is the priority of those options?
■ How are translation conflicts (that is, when two modules translate the
same string) processed by Magento?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Translate::init()
■ Mage_Core_Model_Locale::emulate()

2 – Request Flow
This topic comprises approximately 6% of the exam. Questions are drawn randomly from the
following objectives:
Application initialization
○ Describe the steps for application initialization
○ Change a website from within index.php
Starting with the index.php including Mage.php, follow through the steps
Magento takes to set up the run time environment.
■ How and when is the include path set up and the auto loader registered?
■ How and when does Magento load the base configuration, the module
configuration and the database configuration?
■ How and when are the different types of setup scripts executed?
■ When does Magento decide which store view to use, and when is the
current locale set?
■ Which ways exist in Magento to specify the current store view?
■ When are the request and response objects initialized?
These code references can be used as an entry point to find answers to the
questions above:
■ index.php (no class)
■ Mage_Core_Model_App::run()
■ Mage_Core_Model_Config::loadBase() and init()
Front Controller
○ Locate Front Controller class
○ List all events that Front Controller fires
○ Explain Front Controller responsibilities
Follow the flow of control through the front controller initialization until an
action controller is dispatched.

■ Which ways exist in Magento to add router classes?
■ What is the difference between the different ways to add routers?
■ Think of possible use cases for each of the events fired in the front
controller.
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Controller_Varien_Front::init() and
dispatch()
URL rewrites
○ Describe URL structure/processing in Magento
○ Describe URL rewrite process
○ Rewrite a catalog/product/view to a different URL
Focusing on the internals of database-based URL rewrites, ask yourself:
■ What is the purpose of each of the fields in the core_url_rewrite
table?
■ When does Magento created the rewrite records for categories and
products?
■ How and where does Magento find a matching record for the current
request?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Controller_Varien_Front::dispatch()
■ Mage_Core_Model_Url_Rewrite::rewrite()
Request routing
○ Describe request routing/flow in Magento
○ Create a module with controller
○ Override an existing controller

Starting with the front controller delegating the process of mapping a request
to a controller action, study the steps involved until a controller action is
dispatched.
■ Which routers exist in a native Magento implementation?
■ How does the standard router map a request to a controller class?
■ How does the standard router build the filesystem path to a file that
might contain a matching action controller?
■ How are requests that cannot be mapped processed?
■ After a matching action controller is found, what steps occur before the
action method is executed?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Controller_Varien_Front::init()
■ Mage_Core_Controller_Varien_Router_Standard::coll
ectRoutes() and match()
Module initialization
○ Describe/identify the steps needed to create and register a new module
○ Describe/identify module dependencies
○ Describe/identify the steps needed to enable and disable a module
This objective covers how Magento loads modules and how modules interact
with each other.
■ What does “Magento loads modules” mean?
■ In which order are Magento modules loaded?
■ Which core class loads modules?
■ What are the consequences of a module depending on another?
■ During the initialization of Magento, when are modules loaded in ?
■ Why is the load order important?
■ What is the difference regarding module loading between
Mage::run() and Mage::app()?

These code references can be used as an entry point to find answers to the
questions above:
■ Mage::run() and app()
■ Mage_Core_Model_App::run() and init()
Design and layout initialization
○ Identify the steps in the request flow in which:
■ Design data is populated
■ Layout configuration files are parsed
■ Layout is compiled
■ Output is rendered
○ Describe the module layout XML schema
○ Describe layout fallback
○ Describe admin and frontend scopes
The design configuration is part of Magento’s view implementation. This
objective covers the processing of these XML instructions.
■ Which ways exist to specify the layout update handles that will be
processed during a request?
■ Which classes are responsible for the layout being loaded?
■ How are layout xml directives processed?
■ Which configuration adds a file containing layout xml updates to a
module?
■ Why is the load order of layout xml files important?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Controller_Varien_Action::loadLayout()
■ Mage_Core_Model_Layout::__construct()
■ Mage_Core_Model_Layout_Update::load()

Structure of block templates
○ Define root template, non-output block
○ Describe how to render a root template
○ Describe how to remove a child from the template page
The hierarchical structure of parent and child blocks and the associated
templates compose the other part of Magento’s view implementation.
■ How does Magento store the parent-child relationship once the blocks
have been instantiated?
■ What makes a block an output block?
■ What is the relationship between blocks and templates?
■ Which methods are called during a block’s life cycle?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout::createBlock()
■ Mage_Core_Block_Abstract::toHtml(), setLayout(),
setChild(), insert()
■ Mage_Core_Block_Template::_toHtml()
■ Mage_Core_Block_Text_List::_toHtml()
Flushing data (outputs)
○ Describe how and when Magento renders content to the browser
○ Describe how and when Magento flushes output variables using
Front_Controller
This objective covers the response object as well as combining javascript and
css files.
■ Which events are associated with sending output?
■ Which class is responsible for sending output?
■ What are possible issues when this output is sent to the browser directly
instead of doing it the way Magento is built?
■ How are redirects handled?

These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Controller_Varien_Front::dispatch()
■ Mage_Core_Controller_Response_Http and super
classes
■ Mage_Page_Block_Html_Head::getCssJsHtml()

3 – Rendering
This topic comprises approximately 6% of the exam. Questions are drawn randomly from the
following objectives:
Template structure
○ Define and describe the use of themes in Magento.
■ How you can use themes to customize core functionality?
■ How can you implement different designs for different stores using
Magento themes?
■ In which two ways you can register a custom theme?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Model_Design
■ Mage_Core_Model_Design_Package
○ Define and describe the use of design packages
■ What is the difference between package and theme?
■ What happens if a requested file is missed in your theme/package?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Model_Design
■ Mage_Core_Model_Design_Package
○ Define and describe the use of fallbacks
■ Which kind of path (absolute or relative) does Magento use for
templates and layout files?

■ How exactly does Magento define which physical file corresponds to a
given template/layout?
■ Which classes and methods need to be rewritten in order to add
additional directories to the fallback list?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Model_Design
■ Mage_Core_Model_Design_Package
■ Mage_Core_Controller_Varien_Action
Blocks
○ Describe the structure of blocks
■ What are blocks used for in Magento?
■ What is the parent block for all Magento blocks?
■ Which class is extended by each block that has a template?
■ In which way does a block extending from
Mage_Core_Block_Template store information about a template
file? Does it store an absolute or a relative path to the template file?
■ What is the role of Mage_Core_Block_Abstract class?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage/Core/Block/*
■ Mage_Core_Block_Abstract
■ Mage_Core_Block_Template
■ Mage_Core_Block_Text
■ Mage_Core_Block_Text_List
■ Mage_Page_Block_Html_Head

○ Describe the relationship of templates and blocks
■ Can any block in Magento have a template file?
■ How does the “$this” variable work inside a template?
■ Is it possible to render a template without a block in Magento?
■ Is it possible to have a block without a template in Magento?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Block_Template
■ Mage_Core_Block_Text
■ Mage_Core_Block_Text_List
■ Mage_Page_Block_Html_Head
○ Describe the stages in the lifecycle of a block
■ Which class is responsible for creating an instance of a block?
■ Which class is responsible for figuring out which blocks should be
created for a certain page?
■ How is a block’s tree structure (parent-child hierarchical structure)
rendered on the page?
■ Is it possible to create an instance of a block and render it on the page
without using the layout object?
■ Is it possible to create an instance of a block and add it to the current
layout manually (that is, without layout.xml)?
■ How are block children rendered? Once you have added a child to a
block, can you expect that the child will be rendered automatically?
■ What are the differences in the rendering processes for different types
of blocks?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Block_Abstract
■ Mage_Core_Block_Template
○ Describe events fired in a block
■ How you can catch the output of a block using an observer?
■ What events do Mage_Core_Block_Abstract and
Mage_Core_Block_Template fire?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Block_Abstract
○ Identify different type of blocks
■ What is the purpose of the following block types:
● Mage_Core_Block_Template
● Mage_Core_Block_Text_List
● Mage_Core_Block_Text
■ Which block type renders its children automatically?
■ Which block type is usually used for “content” blocks on Magento
pages?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Block_Template
■ Mage_Core_Block_Text
■ Mage_Core_Block_Text_List
○ Instantiate a block
■ How can you get a block instance from a template? What must you do if
you need an instance of an arbitrary block inside a template?
■ How can you get an instance of a block from a controller?
■ How can you get an instance of a block from an install script or model?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout

■ Mage_Core_Model_Layout_Update
○ Disable block output
■ How can you disable block output in Magento?
■ Which method should you override to get control of a block’s output?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Block_Abstract
○ Describe how the typical block is rendered
■ Which class performs rendering of the template?
■ Which classes are responsible for figuring out the absolute path for
including a template?
■ Which method you should refer to in order to obtain the exact place
where a template is rendered?
■ How you can enable/disable buffering output when a template is being
rendered?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Block_Abstract
■ Mage_Core_Block_Template
Design layout, XML schema, CMS content directives
○ Describe the elements of Magento layout XML schema
■ What are the following instructions used for in Magento layout:
● update
● block
● action

■ How does Magento match a node from layout to its corresponding
URL? Which part of the code is responsible for doing that ?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Model_Design
■ Mage_Core_Model_Design_Package
■ Mage_Core_Controller_Varien_Action
○ Register layout xml file
■ How you can register the layout xml file for frontend and adminhtml
areas?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout_Update
○ Create and add code to pages
■ How can you modify or add code on Magento pages using:
● template customizations
● layout customizations
● overriding blocks
● registering observers on general block events.
■ How does the situation determine which method is best for creating or
adding code?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
○ Pass variable from layout to block.

■ How can you pass a variable to the block from:
● the layout xml file
● a controller
● one block to another
● an arbitrary environment (for instance, install/upgrade scripts,
models, …).
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
○ Add and customize javascript.
■ Which block is responsible for rendering javascript in Magento?
■ Which modes of including javascript does Magento support?
■ How can you add a custom javascript file?
■ If a custom javascript file you added does not appear on the page, what
should you check?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
■ Mage_Core_Model_Design
■ Mage_Core_Model_Design_Package
■ Mage_Core_Controller_Varien_Action
■ Mage/Core/Block/*
■ Mage_Core_Block_Abstract
■ Mage_Core_Block_Template
■ Mage_Core_Block_Text
■ Mage_Core_Block_Text_List
■ Mage_Page_Block_Html_Head

4 – Working with the Database
This topic comprises approximately 11% of the exam. Questions are drawn randomly from the
following objectives:
Models, resource models, and collections
○ Define/describe the basic concepts of models, resource models, and collections
○ Configure a database connection
○ Create and register new entities
○ Load and save an entity from a database
○ Filter and implement group save for a set of records
○ Describe how to use the Zend_Db classes to query the Database
○ Describe how to filter, sort and specify the selected values for collections
○ Describe how the DB abstraction layer for Magento is implemented
○ Describe how to use and resolve existing table names without hardcoding them
Two broad areas make up this objective. The first is about how models work
with resource models and collections in order to access the database storage
layer; the second is about how to work with the database directly, using the
adapter classes and Zend_Db_Select to create queries. Ask yourself the
following questions:
■ Which methods exist to access the table of a resource model?
■ Which methods exist to create joins between tables on collections and
on select instances?
■ How do table name lookups work, and what is the purpose of making
table names configurable?
■ Which events are fired automatically during CRUD operations?
■ How does Magento figure out if a save() call needs to create an
INSERT or an UPDATE query?
■ How many ways exist to specify filters on a flat table collection?

■ Which methods exist to influence the ordering of the result set for flat
table collections? How do the methods differ?
■ Why and how does Magento differentiate between setup, read, and
write database resources?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Abstract
■ Mage_Core_Model_Mysql4_Abstract
■ Mage_Core_Model_Mysql4_Collection_Abstract
■ Mage_Core_Model_Resource::getTableName()
■ Zend_Db_Select
Magento Object Relational Mapping
○ Describe Magento Object Relational Mapping
The model, resource model, and collection models are one layer of the
Magento ORM. The DB abstraction layer and the database itself are another
two layers. This objective overlaps with the previous one.
■ How are model, resource model and collection linked with each other?
■ Which methods are offered by the abstract model and resource model
classes to be used as hooks in custom classes extending them?
■ Which methods exist to access the items in a collection?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Abstract
■ Mage_Core_Model_Mysql4_Abstract
■ Mage_Core_Model_Mysql4_Collection_Abstract
Install and upgrade scripts
○ Describe the Install/Upgrade Workflow
○ Write install and upgrade scripts using set-up resources
○ Write downgrade (rollback) scripts

○ Identify how to use the DDL class in setup scripts
Each module can encapsulate the preparation and upgrade of the database
table it requires via setup scripts.
■ Under which circumstances are setup scripts executed?
■ How and where does Magento differentiate between install, upgrade
and downgrade scripts?
■ What is the difference between the different classes used to execute
setup scripts?
■ Which is the base setup class for flat table entities, and which one the
base for EAV entities?
■ Which methods are generally available in setup scripts to manipulate
database tables and indexes?
■ What is the difference between addAttribute() and
updateAttribute() in EAV setup scripts?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_App::run() and _initModules()
■ Mage_Core_Model_Resource_Setup::applyAllUpdates()
and applyAllDataUpdates()
■ Mage_Eav_Model_Entity_Setup::addAttribute() and
updateAttribute()
5 – Entity Attribute Value (EAV)
This topic comprises approximately 8% of the exam. Questions are drawn randomly from the
following objectives:
EAV model concepts
○ Define basic EAV concepts
○ Describe the EAV hierarchy structure
○ Describe how EAV data storage works in Magento
○ Describe the EAV data access process in Magento
○ Describe the database tables for EAV entities, and how to create them
○ Describe the key differences between EAV and Flat Table collections
○ Given a new entity, identify the factors that influence the choice of the
resource type to use (EAV vs. flat)
This objective covers understanding how EAV entity values are stored in the
database, how the tables involved in these values relate to one another, how
the EAV resource models differ from the flat table resource models and how
the EAV resource models process CRUD operations.
■ Which classes in Mage_Eav are used as resource models and which are
used as regular models?
■ Which entities in a native Magento installation use EAV resource models
and why?
■ What are the advantages and disadvantages of EAV over flat table
resource models?
■ How are store and website scope attribute values implemented in the
Magneto EAV system?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Eav_Model_Config
■ Mage_Eav_Model_Entity_Abstract
■ Mage_Eav_Model_Entity_Collection_Abstract

EAV entity, load and save
○ Describe EAV entity structure and its difference from the standard core
resource model
○ Describe the EAV Load and Save process and its differences from the regular
Load and Save process
Since EAV is part of the data storage layer, the implementation of CRUD
(Create, Read, Update, Delete) processes is at the core of this objective.
■ How do load and save processes for EAV entities differ from those for
flat table entities? What parts are identical?
■ Which classes are involved?
■ What SQL is generated for store scope attribute value updates?
■ What is clever about the SQL that is generated when EAV collections
are loaded?
■ How does the model distinguish between insert and update operations?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Eav_Model_Entity_Abstract::load() and save()
■ Mage_Core_Model_Abstract::load() and save()
■ Mage_Eav_Model_Entity_Collection_Abstract::load()
■ Mage_Core_Model_Mysql4_Collection_Abstract::load(
)
Attributes management
○ Describe EAV attributes, including Frontend-Source-Backend structure
○ Identify the purpose and describe how to implement the interface of attribute
frontend models
○ Identify the purpose and describe how to implement the interface of attribute
source models
○ Identify the purpose and describe how to implement the interface of attribute
backend models

One of the advantages of EAV in Magento is that it offers the option to use
frontend, backend and source models for attributes.
■ How do attribute models, attribute source models, attribute backend
models and attribute frontend models relate to each other?
■ Which methods have to be implemented in a custom source model (or
frontend model or backend model)?
■ Can Adminhtml system configuration source models also be used for
EAV attributes?
■ What is the default frontend model (and source and backend model) for
EAV attributes?
■ Does every attribute use a source model?
■ Which classes and methods are used in updating the EAV attribute
values in the flat catalog tables? Which factors determine which classes
are used?
■ Which frontend, source and backend models are available in a stock
Magento installation?
■ How do multi-lingual options for Attributes work in Magento?
■ How do you get a list of all options for an attribute for a specified store
view in addition to the admin scope?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Eav_Model_Entity_Attribute_Abstract
■ Mage_Eav_Model_Entity_Attribute_Backend_Abstrace
■ Mage_Eav_Model_Entity_Attribute_Frontend_Abstract
■ Mage_Eav_Model_Entity_Attribute_Source_Abstract
■ Mage_Eav_Model_Entity_Attribute_Source_Table
■ Mage_Eav_Model_Mysql4_Entity_Attribute_Option_Col
lection::load()
○ Create and customize attributes
Besides simply using the stock EAV attributes that come with Magento, one of
the most common operations for developers is to modify or create attributes.
■ Which setup methods are available to work with EAV entities?

■ How can an EAV setup class be instantiated in a setup script if not
specified in the XML configuration for a setup resource?
■ What is the difference between addAttribute() and
updateAttribute()?
■ What are the advantages of using a custom setup class for manipulating
EAV attributes in a custom module?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Eav_Model_Entity_Setup

6 – Adminhtml

This topic comprises approximately 6% of the exam. Questions are drawn randomly from the
following objectives:
Common structure/architecture
○ Describe the difference between adminhtml and frontend
Which areas in configuration are loaded for the admin area?
■ What is the difference between admin and frontend controllers?
■ When does Magento figure out which area to use on the current page?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Adminhtml_Controller_Action
■ Mage_Core_Model_Layout
■ Mage_Core_Model_Layout_Update
○ Describe the components of Admin structure
■ At which moment does Magento check if a user is logged in or not?
■ Which class do most Magento adminhtml blocks extend?
■ What is the role of adminhtml config?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Adminhtml_Model_Config
■ Mage_Adminhtml_Model_Config_Data
■ Mage_Admin_Model_Observer
○ Create a controller for admin router
■ How you can make your controller work inside the /admin route?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Controller_Varien_Router_Standard
○ Describe how to operate with cache clearing
■ What are the differences in the different types of cache on the admin
cache cleaning page?
■ What is the difference between “Flush storage” and “Flush Magento
Cache”.
○ Identify how to clear the cache using code (instead of the User Interface)
■ How you can clear the cache without using the UI?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Cache
Form and grid widgets
○ Define form structure, form templates, grids in Magento, and grid containers
and elements
○ Describe grid workflow
○ Create a simple form and grid for a custom entity
○ Describe how to implement advanced Adminhtml Grids and Forms, including
editable cells, mass actions, totals, reports, custom filters and renderers,
multiple grids on one page, combining grids with forms, and adding custom
javascript to an admin form
For study purposes, let’s consider Grids and Forms separately.
○ Grids in Magento.
■ Which block does a standard Magento grid extend?
■ What is a default template for a Magento grid?
■ How can you customize filters for a Magento grid?
■ How does Magento actually perform sorting/paging/filtering
operations?
■ What are the protected methods specific to grids?
■ What is the column class in a grid, and what is its role?
■ What is the role of column renderers in Magento?
■ How can you affect javascripts used for a Magento grid?
■ What is the role of the Grid Container and its template?
■ What is the architecture of massactions in a Magento grid?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Adminhtml_Block_Widget_Grid
■ Mage_Adminhtml_Block_Widget_Grid_Column
■ Mage_Adminhtml_Block_Widget_Grid_Column_Renderer/
*
■ Mage_Adminhtml_Block_Widget_Grid_Column_Filter/*
■ Mage_Adminhtml_Block_Widget_Grid_Container
■ app/design/adminhtml/default/default/template/sal
es/widget/grid.phtml
■ app/design/adminhtml/default/default/template/sal
es/widget/grid/container.phtml
○ Forms in Magento.
■ Which block does a standard Magento form extend?
■ What is a default template for a Magento form?
■ Describe the role of the Form container and its template.
■ Describe the concept of Form elements, and list system elements
implemented in Magento.
■ Describe the concept of Fieldsets.
■ How can you render an element with a custom template?
These code references can be used as an entry point to find answers to the
questions above:
■ lib/Varien/Data/Form/*
■ Mage_Adminhtml_Block_Widget_Form
■ Mage_Adminhtml_Block_Widget_Form_Container
System configuration XML and configuration scope
○ Define basic terms and elements of system configuration XML, including
scopes, website/store/store view
■ How you can render an element with a custom template in system
configuration?
■ What is the structure of system.xml?
■ How you can change the css class of a specific element in system
configuration?
■ How may you specify which elements to show in dropdowns and
multiselects?
■ What is the Magento class structure responsible for rendering system
configuration?
■ How you can specify your own renderer for a field in system
configuration?
■ How does Magento store data for system configuration?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage/Adminhtml/Model/System/Config/*
■ Mage/Adminhtml/Block/System/Config/*
○ Fetch a variable from System config
■ What is the difference between Mage::getStoreConfig(…) and
Mage::getConfig()->getNode(..)?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Core_Model_Config
■ Varien_Simplexml_Config
■ Varien_Simplexml_Element
Access Control Lists (ACL) permissions
○ Define/identify basic terms and elements of ACL
○ Use ACL to:
• Set up a menu item
• Create appropriate permissions for users
• Check for permissions in permissions management tree structures
■ What is the _isAllowed() method used for in Magento, and which
class types can implement it?”
■ What is the xml syntax for adding a new menu element?
■ What is adminhtml.xml used for?
■ Where is the code located that processes the ACL xml, and where is the
code that applies it?
■ What is the relationship between the Magento and Zend ACL systems?
■ What database structure is related to ACL information?
These code references can be used as an entry point to find answers to the
questions above:
■ Admin_Model_Acl
■ Admin_Model_Acl_Resource
■ Admin_Model_Acl_Role
■ Admin_Model_Mysql4_Acl
■ Admin_Model_Mysql4_Role
■ Admin_Model_Mysql4_Roles
■ Admin_Model_Mysql4_Rules
Enabling and configuring extensions
○ Define Magento extensions and describe the different types of extension
available (Community, Core, Commercial)
■ What is the order in which files are loaded from different codepools?
○ Describe how extensions are installed and configured
■ Which folders can a Magento extension affect?
■ Which files are necessary to make a custom module work?
■ What dependencies can Magento modules have, and how can you
control those dependencies?
■ What is the role of the downloader?
■ How can you decouple extensions from Magento?
■ How do Magento extensions connect with and inherit functionality
from the rest of the system, including Payment Methods, etc.?
■ What steps are necessary to install an extension from MagentoConnect?
These code references can be used as an entry point to find answers to the
questions above:
■ downloader/Maged/Controller.php
■ downloader/*
7 – Catalog
This topic comprises approximately 8% of the exam. Questions are drawn randomly from the
following objectives:
Product types
○ Identify/describe standard Product Types (simple, configurable, bundled, etc.)
○ Identify/use standard Magento tools for Product Types
○ Create custom Product Types from scratch or modify existing Product Types
○ Identify how custom Product Types interact with Indexing, SQL, underlying
data structures.
In addition to allowing customization of existing product types, the framework
provided by the Magento catalog module lets you create completely new ones.
■ Which product types exist in Magento?
■ Which product types are implemented as part of the Mage_Catalog
module, and which are not?
■ What steps need to be taken in order to implement a custom product
type?
■ How do the different product types handle price calculation?
■ Which indexing processes does the product type influence?
■ Which product types implement a parent-child relationship between
product entities?
■ Which database tables are shared between product types, and which
ones are specific to one product type?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Catalog_Model_Product_Type
■ Mage_Catalog_Model_Product_Type_Abstract
■ Mage_Catalog_Model_Product_Type_Simple
■ Mage_Catalog_Model_Resource_Eav_Mysql4_Product_Ty
pe_Configurable

■ Mage_Bundle_Model_Product_Type
Price generation
○ Identify basic concepts of price generation in Magento
○ Modify and adjust price generation for products, e.g. during integration of
third-party software
The topic of price calculation in Magento involves several classes and modules.
■ Under what circumstances are product prices read from the index
tables?
■ From which modules do classes participate in price calculation?
■ Which ways exist to specify custom prices during runtime?
■ How do custom product options influence price calculation?
■ How are product tier prices implemented and displayed?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Catalog_Model_Product::getPrice() and
getFinalPrice()
■ Mage_Catalog_Model_Product_Type_Price::getTierPri
ce()
■ Mage_Catalog_Model_Product_Indexer_Price
■ Mage_Catalog_Model_Product_Type_Configurable_Pric
e
Category structure
○ Dynamically alter the category tree structure
○ Choose the best-practice approach to project implementations and upgrades
○ Describe the Category Hierarchy Tree Structure implementation (the internal
structure inside the database), including: the meaning of parent_id 0, the
construction of paths, and the attributes required to display a new category in
the store
Products and categories are independent entities. One may be used with or
without the other, if needed.

■ How are products and categories linked?
■ How is the category hierarchy reflected in the database?
■ How is a catalog tree read from the database tables, with and without
flat catalog tables enabled?
■ How does working with categories differ if the flat catalog is enabled on
a model level?
■ How is the category parent id path set on new categories?
■ Which methods exist to read category children and how do they differ?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Catalog_Model_Category
■ Mage_Catalog_Model_Resource_Eav_Mysql4_Category
■ Mage_Catalog_Model_Resource_Eav_Mysql4_Category_C
ollection
■ Mage_Catalog_Model_Resource_Eav_Mysql4_Category_T
ree
Catalog rules
○ Identify how to implement catalog Price rules
○ Troubleshoot catalog Price rule implementations
Catalog price rules offer many possibilities to manipulate Magento behavior.
Knowing the Mage_CatalogRule module is important for further
customizations and for troubleshooting.
■ How are the catalog price rules used in determining the product prices?
■ How are the catalog price rules stored in the database?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_CatalogRule_Model_Rule
■ Mage_CatalogRule_Model_Observer
■ Mage_CatalogRule_Model_Rule_Product_Price

Other skills
○ Choose optimal catalog structure (EAV vs. Flat) for a given implementation
○ Troubleshoot, customize, and extend the Magento Catalog DB Structure
○ Implement, troubleshoot and modify Magento tax rules
○ Modify, extend and troubleshoot the Magento layered (“filter”) navigation
○ Troubleshoot and customize the Magento Indexes
○ Use custom product options to implement new features
The Magento catalog doesn’t only consist of categories and products: a lot of
additional catalog functionality is implemented, partly within the
Mage_Catalog module, partly in other modules.
■ When and how are the catalog flat tables updated when a product is
modified?
■ Which factors are used by the Mage_Tax module to apply the correct
tax rate (or rates) to a product price?
■ How can attributes with custom source models be integrated in the
filter navigation?
■ Which classes are responsible for rendering the layered navigation?
■ Which indexes are used for the layered navigation?
■ Which steps are needed to integrate a custom indexer into the
framework offered by the Mage_Index module?
■ How are custom product options stored on quote and order items?
■ How can you specify custom product options on-the-fly on quote items?
■ How are custom product options copied from quote to order items?
■ How are custom product options processed when a product is added to
the cart?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Catalog_Model_Product_Indexer_Flat
■ Mage_Catalog_Model_Category_Indexer_Flat
■ Mage_Catalog_Model_Product_Indexer_Eav

■ Mage_Catalog_Model_Resource_Eav_Mysql4_Product_In
dexer_Eav
■ Mage_Tax_Helper_Data:: getPrice()
■ Mage_Catalog_Block_Layer_State
■ Mage_Catalog_Block_Layer_View
■ Mage_Catalog_Model_Layer

8 – Checkout
This topic comprises approximately 13% of the exam. Items are drawn randomly from the
following objectives:
Quote, quote item, address and shopping cart rules in Checkout:
○ Modify these models and effectively use them in customizations
■ What is the Quote model used for in Magento?
■ What is the Shopping cart model used for in Magento?
■ How does Magento store information about the shopping cart?
■ How does Magento process adding products of different types to the
cart?
■ What is the difference between Shipping and Billing address objects in
Magento?
■ What is the difference in processing quote items for onepage and
multishipping checkout in Magento?
■ How does Magento process additional information about products
being added to the shopping cart (custom options, components of
configurable products, etc.).
■ How do products in the shopping cart affect the checkout process?
■ How can the Billing/Shipping address affect the checkout process?
■ When exactly does inventory decrementing occur?
■ When exactly does card authorization/capturing occur?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Sales_Model_Quote
■ Mage_Sales_Model_Quote_Address
■ Mage_Sales_Model_Quote_Item
■ Mage_Sales_Model_Quote_Address_Item
■ Mage_CatalogInventory/etc/config.xml
■ Mage_CatalogInventory_Model_Observer


Total models schema:

○ Add custom Total models or modify existing ones
■ What are Total models responsible for in Magento?
■ How you can customize total models?
■ How you can debug which total models are working for the current
checkout process?
■ How can you affect the order in which total models are executed?
■ Which objects do total models have access to in Magento, and which
objects do they usualy manipulate?
■ Which class runs total models processing?
■ What is the flow of total model execution?
■ At which moment(s) are total models executed?
■ Which total models exist in the core (Mage and Enterprise namespace)?
■ How do they differ in their implementation?
■ Which classes have to be created to implement a custom total model
within the Magento totals framework, that displays in all areas, frontend
(cart, checkout, order history) and backend (order, invoice, PDF)?
■ Which configuration options are required for total models?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage/Sales/etc/config.xml
■ Mage/Tax/etc/config.xml
■ Mage_Sales_Model_Quote_Address
■ Mage_Sales_Model_Quote_Address_Item
■ Mage_Sales_Model_Quote_Address_Total_Abstract
■ Mage_Sales_Model_Quote_Address_Total_Collector
■ Mage/Sales/Model/Quote/Address/Total/*
■ Mage/SalesRule/etc/config.xml
■ Mage_SalesRule_Model_Validator
Shopping cart:
○ Implement shopping cart rules

○ Troubleshoot shopping cart price rules
○ Extend shopping cart price rules
■ Which module is responsible for shopping cart price rules?
■ What is the difference between shopping cart and catalog price rules?
■ What are the limitations of Magento shopping cart rules?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage/SalesRule/etc/config.xml
■ MageSalesRule/Model/*
Shipping/payment methods in Magento
○ Implement shipping methods
○ Troubleshoot shipping methods
■ How does Magento calculate shipping rates?
■ What is the hierarchy of shipping information in Magento?
■ How does the TableRate shipping method work?
■ How do US (FedEX, UPS, USPS) shipping methods work?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Shipping_Model_Carrier_Abstract
■ Mage_Shipping_Model_Rate_Abstract
■ Mage_Shipping_Model_Rate_Request
■ Mage_Shipping_Model_Rate_Result
■ Mage/Shipping/Model/Rate/Result/*
■ Mage_Shipping_Model_Info
■ Mage_Shipping_Model_Carrier/*
■ Mage/Shipping/Model/Mysql4/Carrier/*
○ Troubleshoot payment methods
○ Payment Method Architecture: Implement new payment methods

■ How can you manipulate payment method behavior (like charging or
authorizing a credit card, controlling URL redirects, and so on)?
■ Which class is the basic class in the Payment method hierarchy?
■ How can you control the information that the Payment method stores
in the database (such as credit card number)?
■ What is the difference between Payment method and Payment classes
(such as Order_Payment, Quote_Payment, etc.)?
■ What is the typical structure of the payment method module?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Payment_Model_Method_Abstract
■ Mage_Payment_Model_Method_Cc
■ Mage_Payment_Model_Info
■ Mage/Paypal/*
■ Mage/PaypalUk/*
○ Perform advanced modifications to the shipping rate calculation
■ Which class/method is responsible for fetching shipping rates for a
quote?
■ Describe the roles and dependencies of the following classes involved in
shipping rate calculations: rate, rate request, rate result, carrier, rate
result method, rate result error, info.
■ How is an error in the shipping rate calculation processed?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Shipping_Model_Carrier_Abstract
■ Mage_Shipping_Model_Rate_Abstract
■ Mage_Shipping_Model_Rate_Request
■ Mage_Shipping_Model_Rate_Result
■ Mage/Shipping/Model/Rate/Result/*
■ Mage_Shipping_Model_Info
■ Mage_Shipping_Model_Carrier/*
■ Mage/Shipping/Model/Mysql4/Carrier/*
○ Identify possibilities and limitations of the Magento multishipping
implementation
○ Implement extensions of the Magento multishipping implementation
■ What is the difference in storing quote information between
multishipping and onepage checkouts in Magento?
■ Which quotes will be Virtual?
■ What is the difference in the multishipping processing for a quote with
virtual products in it?
■ How can different product types be split among multiple addresses
when using multishipping in Magento?
■ How many times are total models executed on a multishipping checkout
in Magento?
■ Which model is responsible for multishipping checkout in Magento?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Checkout_Model_Type_Multishipping
■ Mage_Sales_Model_Quote_Address
■ Mage_Sales_Model_Quote

9 – Sales and Customers
This topic comprises approximately 9% of the exam. Questions are drawn randomly from the
following objectives:
Sales
The overall objectives for Sales are:
○ Modify Order Processing and integrate it into ERP integrations
○ Integrate Magento sales architecture with other systems (SAP, NetSuite).
Within those objectives, explore the following topics:
○ Order creation in admin:
■ What classes are involved in order creation from admin? What are their
roles (especially the role of adminhtml classes)?
■ How does Magento calculate price when an order is created from
admin?
■ Which steps are necessary in order to create an order from Magento
admin?
■ What happens when you click “Edit order” in admin?
■ What is the difference between order status and order state?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Sales_Model_Order
■ Mage_Sales_Model_Order_Address
■ Mage_Adminhtml_controllers_Order_CreateController
■ Mage_Adminhtml_Model_Sales_Order_Create
○ Card capturing (Invoice manipulations)
■ Which classes/methods are responsible for credit card operations (like
authorization or capturing)?
■ What is the difference between “pay” and “capture” operations?
■ What is the role of the Order, Order_Payment, Invoice and
Payment methods in the process of charging a card?
■ What is the role of Invoice’s total models?
■ How does Magento store information about invoices?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Sales_Model_Order_Invoice
■ Mage/Sales/Model/Order/Invoice/*
■ Mage_Sales_Model_Order_Payment
■ Mage_Payment_Model_Method_Info
■ Mage_Payment_Model_Method_Abstract
○ Order shipment:
■ How you can manipulate shipment templates?
■ What is the track number and what can you do with it?
■ How can you ship different items from a single order to multiple
addresses? Is it possible at all?
■ How does Magento store shipping information?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Sales_Model_Order_Shipment
■ Mage/Sales/Model/Order/Shipment/*
○ Refund (online and offline)
■ How is the Refund process structured in Magento? Which classes are
involved, and which tables are used to store refund information?
■ How does Magento process taxes when refunding an order?
■ How does Magento process shipping fees when refunding an order?
■ What is the difference between online and offline refunding?
■ What is the role of Credit Memo total models in Magento?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Sales_Model_Order_Creditmemo
■ Mage_Sales_Model_Order_Creditmemo/*
○ Partial operations:
■ How do the following partial operations work in Magento?
● Partial invoice
● partial shipping
● partial refund
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Sales_Model_Order_Invoice
■ Mage_Sales_Model_Order_Payment
■ Mage_Sales_Model_Order_Shipment
■ Mage_Sales_Model_Order_Creditmemo
■ Mage_Payment_Model_Method_Abstract
○ Sales API
■ How can you manipulate the whole order or a specific order item in
Magento?
■ How can you capture a credit card payment using the Magento API?
■ How can you create/edit shipments using the Magento API?
■ How can you refund an order using the Magento API?
■ Does Magento support partial operations via the API? If so, which ones?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage/Sales/etc/api.xml
■ Mage_Sales_Model_Order_Api(_V2)
■ Mage_Sales_Model_Order_Invoice_Api(_V2)
■ Mage_Sales_Model_Order_Shipment_Api(_V2)
○ Cancel operations
■ What cancel operations are available for the various order entities in
Magento (order, order item, shipment, invoice, credit memo)? Do all of
them support cancellation?
■ How is tax processing handled during cancel operations?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Adminhtml_Sales_OrderController
■ Mage_Sales_Model_Order_Invoice
■ Mage_Sales_Model_Order_Payment
■ Mage_Sales_Model_Order_Shipment
■ Mage_Sales_Model_Order_Creditmemo
Customers
○ Add to, delete or customize Customer and Address attributes.
■ What is the structure of tables where customer information is stored?
■ What is the customer resource model?
■ What is the validation process when manipulating customer
information?
■ How can you manipulate customer-related email templates?
■ What is the difference between Shipping and Billing addresses for a
customer?
■ How many addresses can/must any customer have?
■ How does the fact of having/not having some addresses affect what a
customer sees and can do on a site?
■ How does Customer information affect prices and taxes?
■ How can you add an attribute to a customer address? How can you
convert it to an order address?
■ Can a customer be added to two customer groups at the same time?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage/Customer/etc/config.xml
■ Mage_Customer_Model_Customer
■ Mage_Customer_Model_Entity_Customer
■ Mage_Customer_Model_Customer_Address
10 – Advanced Features
This topic comprises approximately 11% of the exam. Questions are drawn randomly from the
following objectives:
Widgets
○ Create frontend Widgets
Magento provides a widget interface that allows for creation of admin-configurable block content.
■ What classes are typically involved in Magento widget architecture?
■ How are admin-configurable parameters and their options specified?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Widget_Model_Widget
API
○ Use the Magento API to implement third party integrations
○ Extend the existing Magento API to allow for deeper integrations into third
party products
○ Describe the different Web Service APIs available within the Magento Core
○ Describe the advantages and disadvantages of the available Web Service APIs in
Magento
○ Identify the configuration files used for the v2 SOAP API
○ Describe the purpose of the configuration files related to the API
Magento has an extensible API which exposes several core module entities and
configuration via SOAP and XML-RPC to facilitate integration with third party
applications.
■ What are the syntactical differences between API versions?
■ How is the final WSDL composed? How can it be customized?
■ How are existing methods overwritten? How can additional methods be
added?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Api_Model_Wsdl_Config
■ Mage_Api_Model_Server
Other skills
○ Advanced Grid/Forms: Design, use, and implement new advanced grids and
forms
○ Advanced system configuration: Implement interactive and highly customized
system configuration interface
Magento’s Adminhtml interface is readily extendable. Extending the Adminhtml
interface requires an understanding of container, widget, and form element
classes in addition to being able to work with the XML responsible for the
system configuration panel.
■ Which container classes are typically used to implement custom forms
and grid views?
■ Which additional methods are used when creating Adminhtml grid
views?
■ What is the structure of the XML used to build System Configuration
views?
These code references can be used as an entry point to find answers to the
questions above:
■ Mage_Adminhtml_Block_Widget_Grid
■ Mage_Adminhtml_Block_Widget_Form
■ Mage_Adminhtml_Block_System_Config_Form
11 – Enterprise Edition
This topic comprises approximately 9% of the exam. Questions are drawn randomly from the
following objectives:
○ Customize, extend, and troubleshoot Enterprise Edition catalog target rules
The Enterprise Edition target rules are implemented in the module
Enterprise_TargetRule.
■ How does the Enterprise target rule module extend the possibilities
offered by the Community Edition linked products?
■ How does the module store the rules in the database?
■ Which indexer processes the rules, and how is the index used to realize
faster reads?
These code references can be used as an entry point to find answers to the
questions above:
■ Enterprise_TargetRule_Model_Rule
■ Enterprise_TargetRule_Model_Mysql4_Index
■ Enterprise_TargetRule_Model_Observer
○ Customize, extend, and troubleshoot the Enterprise Edition reward point
system
The Enterprise Edition reward point system is implemented in the module
Enterprise_Reward.
■ How do the features offered by the reward point system hook into
other Magento modules?
■ Which possibilities assign customers reward points?
■ Which steps are required to add new custom options to assign reward
points?
These code references can be used as an entry point to find answers to the
questions above:
■ Enterprise_Reward_Model_Observer
■ Enterprise_Reward_Model_Reward_Rate::calculateToC
urrency() and calculateToPoints()
■ Enterprise_Reward_Helper_Data::getRateFromRatesAr
ray()
○ Implement, customize, and troubleshoot Enterprise Edition website restrictions
The Enterprise Edition website restrictions are implemented in the module
Enterprise_WebsiteRestriction.
■ How does the website restrictions module determine which pages are
accessible without authentication?
■ How does the module prevent visitors from accessing restricted website
content?
These code references can be used as an entry point to find answers to the
questions above:
■ Enterprise_WebsiteRestriction_Model_Observer
■ Enterprise_WebsiteRestriction_Block_Cms_Stub
○ Identify the elements and functioning of Enterprise Edition Full Page Cache
The Enterprise_PageCache module is one of the most widely used
Enterprise Edition modules.
■ How does the Enterprise_PageCache module hook into the
request flow and serve pages from the cache?
■ What is the difference between the applyWithoutApp() and
applyInApp() methods of the abstract? What is the role of each
node in the cache.xml configuration file?
■ Which steps are necessary to implement a dynamically rendered block
inside an otherwise fully cached page?
These code references can be used as an entry point to find answers to the
questions above:
■ Enterprise_PageCache_Model_Observer
■ Enterprise_PageCache_Model_Container_Abstract
■ Enterprise_PageCache_Model_Processor_Default
12 – Challenge Questions
Approximately 8% of the Magento Certified Developer Plus exam consists of Challenge
questions, randomly drawn from the objectives covered in the individual sections of this Study
Guide. The Challenge questions go into more detail or cover more complex areas of the topic
than the questions in the other sections of the Magento Certified Developer Plus exam.

Sample Questions
These questions are representative of the types of question on the exam. Answers are given
on the page following the last question.

1- In which of the following methods would you log event names?
A. Mage::addObserver()
B. Varien_Event::dispatchEvent()
C. Mage::logEvent()
D Mage_Core_Model_App::dispatchEvent()
2- In which order are translations loaded?

1- Module translation files under app/locale/[locale]/*.xml
2- Translations stored in the DB table core_translate
3- Theme translations in the translate.csv file located in the theme
locale/[locale]/ directory

A. 1,2,3
B. 1,3,2
C. 2,1,3
D. 2,3,1
3 – When specifying a custom connection resource for a module that handles the DB reads,
which of the following is a possible resource name?
A.
B.
C.
D.
E.
4 – Assuming a setup class of Mage_Sales_Model_Mysql4_Setup, which of the
following will correctly add an attribute to the sales/order entity? A. $installer->addAttribute(‘sales_order_entity’,’foo’,array
(‘type’=> ‘int’));
B. $installer->addAttribute(‘sales/order’, ‘foo’, array(‘type’
=>’int’));
C. $installer->addAttribute(‘order’, ‘foo’, array(‘type’ =>
‘int’));
D. $installer->addAttribute(‘sales_flat_order’, ‘foo’,
array(‘type’ =>’int’));
Answers to Sample Questions

1-D
2-B
3-B
4-C

Comments Closed