Trilha de estudo
Trilha Desenvolvimento SAP ABAP: tudo o que estudar, tópico por tópico
Avaliação de nível certificação para desenvolvimento SAP ABAP: fundamentos da linguagem, modelagem de dados e persistência (Open SQL, CDS, AMDP), ABAP orientado a objetos, UI clássica e moderna (ALV, RAP), enhancements, interfaces e integração (BAdIs, IDocs, RFC, OData) e ABAP Cloud, ferramentas (ADT) e qualidade (ATC, ABAP Unit) — alinhada às certificações SAP Certified Development Associate em ABAP.
Resposta curta
Para aprender Desenvolvimento SAP ABAP, percorra 6 módulos e 45 tópicos na ordem em que um apoia o próximo. Comece por Fundamentos da Linguagem ABAP e siga para Modelagem de Dados e Persistência e ABAP Orientado a Objetos. Use o mapa como checklist, ou meça seu nível e estude só o que falta.
O que você vai estudar
Os tópicos estão agrupados por módulo. Abra um para ver os objetivos e os conceitos-chave.
1 · Fundamentos da Linguagem ABAP8 tópicos
Data Types & Variable Declarations
ABAP elementary data types (C, N, I, P, D, T, X, F, STRING, XSTRING), type declarations with TYPES and DATA, constants, literals, type reference with LIKE and TYPE, and work areas vs header lines
Objetivos
- Declare variables using DATA and TYPES with correct elementary types
- Distinguish between LIKE and TYPE references for structured data
- Explain the difference between work areas and header lines
Conceitos-chave
- elementary data types
- DATA statement
- TYPES declaration
- CONSTANTS
- LIKE vs TYPE
- work area
Internal Tables (Standard, Sorted, Hashed)
Internal table types and their index/key access semantics; APPEND, INSERT, READ TABLE, LOOP AT, DELETE, SORT, COLLECT; table keys; performance implications of each table type
Objetivos
- Choose the appropriate internal table type based on access pattern requirements
- Perform CRUD operations on internal tables using standard ABAP statements
- Explain the performance trade-offs between standard, sorted, and hashed tables
Conceitos-chave
- standard table
- sorted table
- hashed table
- table key
- READ TABLE WITH KEY
- LOOP AT WHERE
Control Structures & Loops
IF/ELSEIF/ELSE/ENDIF, CASE/WHEN, DO/WHILE/LOOP/EXIT/CONTINUE/CHECK, nested loops with AT NEW/END OF, and the ABAP logical expression operators
Objetivos
- Write conditional logic using IF and CASE constructs correctly
- Implement loops over internal tables with group-by processing using AT NEW/END OF
Conceitos-chave
- IF statement
- CASE statement
- DO loop
- WHILE loop
- LOOP AT
- AT NEW / END OF
String Processing
ABAP string operations: CONCATENATE, SPLIT, REPLACE, SEARCH, SHIFT, string templates with |...|, regular expression matching, and offset/length notation for character fields
Objetivos
- Use string templates and classic string operations for text manipulation
- Apply offset-length notation and FIND/REPLACE for character field processing
Conceitos-chave
- CONCATENATE
- SPLIT AT
- string template |...|
- REPLACE
- SEARCH / FIND
- offset-length notation
Field Symbols & Data References
FIELD-SYMBOLS for dynamic assignment and performance loops; data references with REF TO and DEREF; dynamic programming with field symbols vs data references; casting
Objetivos
- Use field symbols to access internal table rows without copying data
- Explain when to use data references vs field symbols for dynamic programming
Conceitos-chave
- FIELD-SYMBOLS
- ASSIGN ... TO <fs>
- data reference REF TO
- DEREF
- dynamic table access
- casting with CASTING TYPE
Modularization: FORMs, Function Modules & Methods
Subroutines (FORM/ENDFORM), function modules in function groups, parameter types (USING/CHANGING/TABLES/RETURNING/RAISING), local vs global classes as modularization units, and when to prefer each approach
Objetivos
- Implement modular programs using FORMs and function modules with correct parameter types
- Distinguish pass-by-reference from pass-by-value in ABAP subroutines
Conceitos-chave
- FORM/PERFORM
- FUNCTION MODULE
- function group
- USING/CHANGING/RETURNING
- CALL FUNCTION
- pass by reference vs value
ABAP Dictionary (DDIC) Basics
ABAP Dictionary objects: data elements, domains, transparent tables, structures, table types; TYPE POOLS; search helps; lock objects; activation and delivery classes
Objetivos
- Create DDIC objects (domain, data element, table) and explain their relationships
- Use lock objects to implement enqueue/dequeue locking in ABAP programs
Conceitos-chave
- domain
- data element
- transparent table
- structure
- table type
- search help
- lock object
Open SQL Basics
Introductory Open SQL: SELECT single, SELECT ... INTO TABLE, WHERE clause with comparison and IN operators, ORDER BY, INSERT/UPDATE/DELETE statements, and the SY-SUBRC return code
Objetivos
- Write Open SQL statements to read and modify database table data
- Handle SY-SUBRC correctly to detect empty results and DML failures
Conceitos-chave
- SELECT INTO TABLE
- SELECT SINGLE
- WHERE clause
- SY-SUBRC
- INSERT/UPDATE/DELETE
- FOR ALL ENTRIES IN
2 · Modelagem de Dados e Persistência8 tópicos
Database Tables & Views in DDIC
Transparent tables, pooled and cluster tables (legacy), DDIC views (database view, help view, maintenance view, projection view), delivery classes, table maintenance generator, and buffering settings
Objetivos
- Design transparent tables with appropriate field types, keys, and foreign key relationships
- Select the correct DDIC view type for a given use case
Conceitos-chave
- transparent table
- DDIC view types
- delivery class
- table maintenance generator
- foreign key relationship
- check table
Open SQL & SELECT Variants
Advanced Open SQL: JOINs (inner, left outer), sub-queries, GROUP BY / HAVING, aggregate functions, FOR ALL ENTRIES IN, SELECT with host variables, and the @data( ) inline declaration syntax
Objetivos
- Write complex SELECT statements with JOINs, sub-queries, and aggregations
- Use FOR ALL ENTRIES IN safely and understand its null-set pitfall
Conceitos-chave
- INNER JOIN / LEFT OUTER JOIN
- sub-query
- GROUP BY / HAVING
- aggregate functions
- FOR ALL ENTRIES IN
- inline @data( ) declaration
CDS Views (Core Data Services)
Core Data Services: DDL source, define view, data source references, CDS SELECT with expressions and built-in functions, exposing CDS as virtual data model (VDM), CDS test doubles in ABAP Unit
Objetivos
- Create CDS view entities that expose DDIC tables as a virtual data model
- Use CDS built-in functions and expressions for field-level calculations
Conceitos-chave
- CDS DDL source
- DEFINE VIEW ENTITY
- CDS SELECT
- CDS built-in functions
- virtual data model (VDM)
- CDS test double
CDS Associations & Annotations
CDS associations (to-one, to-many), path expressions in SELECT, OData annotations (@OData.publish), UI annotations (@UI.lineItem), access control annotations (@AccessControl), and CDS roles / DCL
Objetivos
- Define CDS associations and use path expressions for navigation across entities
- Apply OData and UI annotations to expose CDS views for Fiori consumption
Conceitos-chave
- CDS association
- path expression
- to-one vs to-many
- @OData.publish annotation
- @UI annotations
- DCL / access control
ABAP Managed Database Procedures (AMDP)
AMDP framework: implementing SAP HANA SQLScript procedures from ABAP classes; AMDP method signature, BY DATABASE PROCEDURE FOR HDB, tabular input/output parameters, and AMDP function implementations
Objetivos
- Implement ABAP Managed Database Procedures to push complex calculations to HANA
- Explain when AMDP is preferable over Open SQL and the portability trade-offs
Conceitos-chave
- AMDP class interface IF_AMDP_MARKER_HDB
- BY DATABASE PROCEDURE FOR HDB
- SQLScript in ABAP
- tabular parameters
- AMDP function
- AMDP test doubles
Table Buffering & Performance
SAP application server table buffering types (full, generic, single-entry), when buffering is appropriate, BYPASS BUFFER, shared memory objects, and Open SQL performance best practices (index usage, result set size)
Objetivos
- Configure the appropriate buffering type for a DDIC table based on data volatility
- Identify and resolve common Open SQL performance anti-patterns
Conceitos-chave
- full buffering
- generic buffering
- single-entry buffering
- BYPASS BUFFER
- shared memory object
- index-aware SELECT
LUW & Database Commits
SAP Logical Unit of Work vs database transaction; COMMIT WORK vs COMMIT WORK AND WAIT; ROLLBACK WORK; bundling techniques (update task, subroutine, function module in update); PERFORM ON COMMIT; and transaction atomicity in ABAP
Objetivos
- Explain the difference between SAP LUW and database LUW and their interaction
- Implement update task bundling to ensure atomicity across multiple table changes
Conceitos-chave
- SAP LUW
- database LUW
- COMMIT WORK
- ROLLBACK WORK
- update task
- PERFORM ON COMMIT
Secondary Indexes & Query Tuning
Creating secondary indexes in DDIC, composite index design, analyzing query plans with SQL trace (ST05) and SAT, selective WHERE conditions, avoiding full table scans, and HANA-specific index considerations
Objetivos
- Design secondary indexes that improve query selectivity for critical Open SQL statements
- Use ST05 and SAT to identify slow queries and validate index usage
Conceitos-chave
- secondary index (DDIC)
- composite index
- ST05 SQL trace
- selectivity
- full table scan avoidance
- HANA column store index
3 · ABAP Orientado a Objetos7 tópicos
Classes & Objects
Defining ABAP classes: CLASS ... DEFINITION / IMPLEMENTATION, visibility sections (PUBLIC/PROTECTED/PRIVATE), instance and static members, constructors (instance constructor, static constructor), method calls with object references
Objetivos
- Define ABAP classes with correct visibility sections and constructor patterns
- Distinguish between instance and static components and their lifecycle
Conceitos-chave
- CLASS DEFINITION
- PUBLIC / PROTECTED / PRIVATE section
- instance attribute
- static attribute
- instance constructor
- static constructor
Inheritance & Polymorphism
Single inheritance in ABAP (INHERITING FROM), method redefinition (REDEFINITION), calling super constructor (super->constructor), abstract classes and methods, final classes and methods, and polymorphic object reference assignment
Objetivos
- Implement inheritance hierarchies with correct super-constructor chaining
- Apply polymorphism through up-cast and down-cast object reference assignments
Conceitos-chave
- INHERITING FROM
- REDEFINITION
- super->constructor( )
- abstract class/method
- final class/method
- up-cast / down-cast
Interfaces
INTERFACE definition, INTERFACES statement in class definition, interface method implementation, interface reference variables, and the use of interfaces for contract-based programming and test doubles
Objetivos
- Define and implement ABAP interfaces and use interface references for polymorphism
- Explain how interfaces enable test isolation through dependency injection
Conceitos-chave
- INTERFACE statement
- INTERFACES keyword
- interface reference variable
- interface prefix (intf~method)
- contract-based programming
- interface for test doubles
ABAP Events & Exception Classes
ABAP OO events (EVENTS, RAISE EVENT, SET HANDLER), exception classes hierarchy (CX_ROOT, CX_STATIC_CHECK, CX_DYNAMIC_CHECK, CX_NO_CHECK), TRY/CATCH/CLEANUP/ENDTRY, raising and re-raising exceptions, and exception texts with message class binding
Objetivos
- Implement class-based exception handling with appropriate exception class hierarchy
- Use ABAP OO events and handlers to implement observer patterns
Conceitos-chave
- EVENTS / RAISE EVENT
- SET HANDLER
- CX_STATIC_CHECK
- TRY/CATCH/ENDTRY
- RAISE EXCEPTION TYPE
- exception text binding
ABAP Unit Testing
ABAP Unit framework: test classes (FOR TESTING), test methods, assertions (CL_ABAP_UNIT_ASSERT), setup/teardown methods, test doubles using interfaces, and running unit tests in ADT and SE80
Objetivos
- Write ABAP Unit test classes with setup/teardown and assertion calls
- Implement test doubles using interfaces to isolate units under test
Conceitos-chave
- FOR TESTING class
- CL_ABAP_UNIT_ASSERT
- SETUP / TEARDOWN
- test double via interface
- test seam
- risk level / duration annotation
Design Patterns in ABAP (Factory, Singleton)
Applying Gang-of-Four creational patterns in ABAP: factory method pattern using static factory methods, singleton pattern with private constructor, and strategy/template-method patterns; when patterns improve maintainability
Objetivos
- Implement the factory method and singleton patterns correctly in ABAP classes
- Identify which design pattern resolves a given coupling or testability problem
Conceitos-chave
- factory method pattern
- singleton pattern
- strategy pattern
- template method pattern
- private constructor
- pattern-driven testability
Global vs Local Classes
Global classes in Class Builder (SE24) vs local classes within a program; local class include sections (LIMU CPUB/CPRI/CPRO/CIMP/CCMAC); friend classes, and when to publish a class globally vs keep it local
Objetivos
- Decide when to create a global vs local ABAP class and manage visibility
- Use the friend class concept to selectively expose private members for testing
Conceitos-chave
- global class (SE24)
- local class
- LIMU include
- friend class (FRIENDS)
- class library
- class visibility scope
4 · UI Clássica e Moderna / Frameworks7 tópicos
Classic Reports & Selection Screens
Executable program (report) structure, WRITE/ULINE/SKIP output, PARAMETERS and SELECT-OPTIONS on selection screens, AT SELECTION-SCREEN events, INITIALIZATION event, and START-OF-SELECTION
Objetivos
- Build an executable ABAP report with a selection screen and list output
- Use AT SELECTION-SCREEN events to validate and enrich selection screen input
Conceitos-chave
- REPORT program
- PARAMETERS statement
- SELECT-OPTIONS
- AT SELECTION-SCREEN
- START-OF-SELECTION
- WRITE statement
ALV (SALV & REUSE_ALV)
ABAP List Viewer output: REUSE_ALV_GRID_DISPLAY function module approach, and the modern SALV object model (CL_SALV_TABLE); field catalog, layout settings, sorting, filtering, totals, and event handling on ALV
Objetivos
- Display internal table data using both SALV and classic REUSE_ALV approaches
- Customize ALV field catalog and attach event handlers for interactive reports
Conceitos-chave
- CL_SALV_TABLE
- REUSE_ALV_GRID_DISPLAY
- field catalog
- ALV layout
- ALV sorting / filtering
- ALV event handler
Module Pool & Dynpro Programming
Screen (dynpro) programming: screen painter, PAI/PBO modules, flow logic, field and module statements, table controls, tabstrip controls, GUI status and title, and OK_CODE handling
Objetivos
- Design a module pool program with PAI/PBO flow logic and screen navigation
- Implement table controls and OK_CODE handling for complex dialog transactions
Conceitos-chave
- dynpro screen
- PAI / PBO
- flow logic
- CALL SCREEN
- table control
- GUI status (SET PF-STATUS)
BOPF Overview
Business Object Processing Framework: business objects, nodes, actions, determinations, validations, and associations in BOPF; BOPF as predecessor of RAP; interaction pattern via IF_BOC_SERVICE_MANAGER
Objetivos
- Describe the BOPF architecture including nodes, actions, and determinations
- Explain the conceptual relationship between BOPF and the newer RAP model
Conceitos-chave
- BOPF business object
- BOPF node
- action / determination / validation
- IF_BOC_SERVICE_MANAGER
- BOPF interaction layer
- BOPF vs RAP
RAP (RESTful ABAP Programming Model) Introduction
RAP architecture: CDS view entities as data model, behavior definition (BDEF), behavior implementation class (BI), managed vs unmanaged providers, draft handling concept, and the RAP BO contract
Objetivos
- Design a RAP business object with CDS data model, BDEF, and behavior implementation
- Compare managed and unmanaged provider strategies and choose appropriately
Conceitos-chave
- behavior definition (BDEF)
- behavior implementation class
- managed provider
- unmanaged provider
- RAP draft handling
- RAP BO contract
Fiori/OData via SEGW & RAP
Creating OData services with Service Builder (SEGW): entity types, entity sets, navigation properties, DPC/MPC extension classes; and exposing RAP business objects as OData V4 services; Fiori elements and annotation-driven UIs
Objetivos
- Create and register an OData service using SEGW with entity types and navigation
- Expose a RAP business object as an OData V4 service for Fiori Elements consumption
Conceitos-chave
- SEGW service builder
- OData entity type / entity set
- DPC extension class
- OData V4 via RAP
- Fiori elements
- @UI annotation for Fiori
BAPIs & Enhancement Basics
Business Application Programming Interfaces (BAPIs): BAPI concept, BAPI_TRANSACTION_COMMIT, error handling via RETURN table; overview of enhancement framework concepts as a bridge to the next category
Objetivos
- Call BAPIs correctly including BAPI_TRANSACTION_COMMIT and RETURN table evaluation
- Explain the Business Object Repository (BOR) and how BAPIs are published
Conceitos-chave
- BAPI
- BAPI_TRANSACTION_COMMIT
- RETURN parameter table
- BAPI error handling pattern
- business object repository (BOR)
- enhancement concept overview
5 · Enhancements, Interfaces e Integração8 tópicos
Enhancement Framework (BAdIs & Enhancement Spots)
SAP enhancement framework: implicit enhancement spots (begin/end of include), explicit enhancement spots, BAdI definition and implementation, classic vs new BAdI, filter-dependent BAdIs, and fall-through behavior
Objetivos
- Implement a BAdI to enhance standard SAP functionality without modifying standard code
- Distinguish implicit enhancement spots, explicit spots, and BAdIs and when to use each
Conceitos-chave
- implicit enhancement spot
- explicit enhancement spot
- BAdI definition
- BAdI implementation
- classic BAdI (BADI_DEF)
- new BAdI (GET BADI)
User Exits & Customer Exits
Pre-enhancement-framework extension techniques: user exits (FORM routines in includes), customer exits (EXIT_ function modules in function groups), field exits, menu exits, and screen exits; identifying available exits via CMOD/SMOD
Objetivos
- Find and implement customer exits using SMOD/CMOD for legacy SAP enhancements
- Compare user exits, customer exits, and BAdIs in terms of flexibility and upgrade safety
Conceitos-chave
- user exit
- customer exit (SMOD/CMOD)
- EXIT_ function module
- field exit
- screen exit
- project activation in CMOD
IDocs & ALE
IDoc structure (control record, data record, status record), IDoc types and message types, Application Link Enabling (ALE) configuration, partner profiles, inbound/outbound processing, and IDoc monitoring (BD87/WE02)
Objetivos
- Describe the IDoc architecture and configure inbound/outbound processing for a message type
- Monitor and reprocess failed IDocs using BD87 and the status record
Conceitos-chave
- IDoc control record
- IDoc data record
- message type
- partner profile
- ALE distribution model
- BD87 / WE02 monitoring
RFC & Remote Function Modules
RFC-enabled function modules: CALL FUNCTION ... DESTINATION, synchronous RFC (sRFC), asynchronous RFC (aRFC), transactional RFC (tRFC), queued RFC (qRFC), RFC destinations (SM59), and error handling in remote calls
Objetivos
- Configure RFC destinations and implement error handling in remote function calls
- Select the appropriate RFC type (sRFC/aRFC/tRFC/qRFC) for a given integration scenario
Conceitos-chave
- RFC-enabled function module
- CALL FUNCTION DESTINATION
- sRFC / aRFC / tRFC / qRFC
- SM59 RFC destination
- COMMUNICATION_FAILURE exception
- SYSTEM_FAILURE exception
Proxies & Web Services (SOAP/REST)
ABAP proxy generation from WSDL, Enterprise Services Repository (ES Repository), calling external SOAP web services from ABAP, and consuming REST services using CL_HTTP_CLIENT and HTTP destinations (SM59)
Objetivos
- Generate and invoke an ABAP proxy for an external SOAP web service
- Consume a REST endpoint from ABAP using CL_HTTP_CLIENT with error handling
Conceitos-chave
- ABAP proxy generation
- WSDL import
- Enterprise Services Repository
- CL_HTTP_CLIENT
- HTTP destination (SM59)
- SOAP vs REST from ABAP
BAPIs & Business Object Model
BOR (Business Object Repository) deeper dive: business object types, methods, events, and key fields; BAPI standards (naming, RETURN table, COMMIT handling); and creating custom BAPIs in ZBOR objects
Objetivos
- Implement a custom BAPI following SAP naming conventions and RETURN table standards
- Register a custom BOR object type and publish BAPIs for external consumers
Conceitos-chave
- BOR object type
- BAPI method
- BOR event
- BAPI naming convention
- BAPI_TRANSACTION_COMMIT pattern
- custom BOR object (ZBOR)
Background Processing & Job Scheduling
Scheduling ABAP programs as background jobs: SM36/SM37, job variants, job classes (A/B/C), start conditions (time-based, event-based), spool management, and SUBMIT ... VIA JOB from ABAP
Objetivos
- Schedule and monitor ABAP programs as background jobs using SM36/SM37
- Use SUBMIT ... VIA JOB to programmatically trigger background execution
Conceitos-chave
- SM36 job definition
- SM37 job monitoring
- job class
- start condition
- SUBMIT VIA JOB
- spool request
Batch Input (BDC) & LSMW
Batch Data Communication: recording transactions (SHDB), BDC program structure (BDC_TAB internal table, CALL TRANSACTION USING), session method vs call transaction method; Legacy System Migration Workbench (LSMW) for structured data migration
Objetivos
- Implement a BDC program using the call transaction method with error session
- Compare BDC session method vs call transaction method for bulk data entry scenarios
Conceitos-chave
- BDC recording (SHDB)
- BDC_TAB / BDC_FIELD
- CALL TRANSACTION USING
- session method (BDC session)
- call transaction method
- LSMW migration
6 · ABAP Cloud, Ferramentas e Qualidade7 tópicos
ABAP Development Tools (ADT) in Eclipse
Eclipse-based ABAP IDE: project setup, key perspectives and views, code completion, syntax check, quick fixes, ABAP perspective navigation, inline test runner, and transport integration in ADT
Objetivos
- Configure an ADT ABAP project and navigate the core IDE perspectives and views
- Execute ABAP Unit tests and interpret results directly within ADT
Conceitos-chave
- ABAP project in Eclipse
- ADT perspective
- quick fix (ABAP Cleaner)
- inline ABAP unit runner
- ADT transport integration
- code search in ADT
ABAP Cloud & Released APIs
ABAP Cloud programming model: the released API concept (C1/C2 contracts), SAP Object Types with release state, use of ONLY released repository objects, and how to find released APIs via ABAP API Reference and ADT
Objetivos
- Identify released SAP APIs and use only C1/C2 objects in ABAP Cloud programs
- Locate available released APIs for a given functional domain using ADT and API reference
Conceitos-chave
- released API (C1 contract)
- C2 use contract
- API release state
- ABAP API reference
- deprecated object handling
- cloud-ready vs on-premise API
Clean Core & Released-Object Concept
SAP clean-core strategy: avoiding modifications to standard objects, the role of extensibility (key-user, developer extensibility), ABAP Cloud language restrictions, and upgrade stability through clean-core compliance
Objetivos
- Explain the clean-core principle and its implications for custom development strategy
- Classify customizations by extensibility tier (key-user vs developer) and compliance risk
Conceitos-chave
- clean core
- key-user extensibility
- developer extensibility
- ABAP Cloud language restriction
- modification assistant
- upgrade stability
Code Quality: ATC & Code Inspector
ABAP Test Cockpit (ATC): check variants, check categories (security, performance, maintainability), exemption workflow; Code Inspector (SCI) and extended program check (SLIN); integrating ATC into transport release gates
Objetivos
- Configure ATC check variants and interpret findings by category and priority
- Set up ATC as a transport release gate to enforce quality standards
Conceitos-chave
- ABAP Test Cockpit (ATC)
- ATC check variant
- exemption workflow
- Code Inspector (SCI)
- extended program check (SLIN)
- ATC transport gate
Debugging & Runtime Analysis (ST22 / SAT / SQL Trace)
ABAP debugger: breakpoints (session, external, watch), debugging internal tables and object instances; short dump analysis with ST22; runtime analysis with SAT (ABAP Trace); SQL trace with ST05 for database performance investigation
Objetivos
- Set breakpoints and watch points to trace runtime behaviour in the ABAP debugger
- Analyse short dumps (ST22), runtime profiles (SAT), and SQL traces (ST05) to diagnose issues
Conceitos-chave
- ABAP debugger breakpoints
- external breakpoint
- watch point
- ST22 short dump
- SAT runtime analysis
- ST05 SQL trace
Transport Management System (CTS)
CTS fundamentals: change requests (workbench vs customizing), tasks, system landscape (DEV→QAS→PRD), import queue, transport routes (STMS), emergency transports, and transport of copies
Objetivos
- Manage workbench change requests through the DEV→QAS→PRD transport route
- Resolve transport conflicts and import failures using STMS import queue
Conceitos-chave
- workbench change request
- customizing change request
- task in transport request
- import queue (STMS)
- transport route
- transport of copies
ABAP Unit & Test-Driven Quality Gates
Test-Driven Development (TDD) workflow in ABAP: red-green-refactor cycle, test coverage analysis, ABAP Test Cockpit integration with CI pipelines, test isolation strategies (test seams, dependency injection), and quality gates enforced at transport release
Objetivos
- Apply the TDD cycle to ABAP development and measure coverage with the ABAP Unit runner
- Integrate ATC quality checks into a transport-release gate for automated enforcement
Conceitos-chave
- TDD red-green-refactor
- test coverage report
- ATC CI integration
- test seam
- dependency injection in ABAP
- quality gate at transport
Níveis: Júnior, Pleno e Sênior
Explique com suas palavras
Corrigido por IA · sem cadastro · 1 perguntaSem alternativas para chutar: você escreve, a IA corrige com a rubrica do tópico e diz em que nível sua resposta está.
Já estuda Desenvolvimento SAP ABAP?
A avaliação mede tópico por tópico, e o plano pula o que você já sabe.
Aberto para ler. A conta só é necessária para ser medido.
Perguntas frequentes
Por onde começar a estudar Desenvolvimento SAP ABAP?
Comece por Fundamentos da Linguagem ABAP: Data Types & Variable Declarations, Internal Tables (Standard, Sorted, Hashed) e Control Structures & Loops. O mapa ordena os tópicos pelo que depende de quê, então cada um prepara o seguinte.
Quanto tempo leva uma avaliação completa de Desenvolvimento SAP ABAP?
Uma avaliação completa desta trilha leva cerca de 45 minutos. O tempo de estudo depende de onde você começa; o diagnóstico mostra quais tópicos você pode pular.
Preciso de conta para usar esta página?
Não. O mapa, os objetivos e os conceitos-chave são abertos. A conta só é necessária para ser medido, ver seu gap por tópico e receber um plano.