Test-Driven Development with ABAP Objects

Language

🇺🇸 English

Publisher SAP PRESS

Year / Edition 2019 / 1

Pages 594

Authors Winfried Schwarzmann

Test-Driven Development with ABAP Objects

Better, cleaner code—every developer’s dream. Test-driven development is how you’ll achieve it! From creating a robust test infrastructure to designing methods, classes, and packages that will stand the test of time, this book provides in-depth instructions for revitalizing your programming. Whether you’re writing new code or fixing legacy code, you’ll learn to select test cases, use test doubles, and generate test data. With information on agile methodology to round out the development process, you’ll have all the tools you need!

Use test-driven and agile development to write more robust ABAP programs
Clean up new and legacy code, minimize dependencies, and improve development efficiency
Create integration tests, component tests, and more

You'll learn about:

Test-Oriented Design:
Use test-driven development guidelines while designing the methods and classes used in your application. While you work, improve your coding with test doubles and test classes.
Agile Methodology:
Learn about the Scrum framework and the Lean development model. Then, discover the most important practices of agile software engineering including refactoring, pair programming, and more.
Code Examples:
Use ABAP in Eclipse and test isolation frameworks to develop new applications, redesign existing components, and refactor legacy code. Numerous diagrams help you understand code samples that are as demanding as your daily work.

Key Highlights:

Object-oriented design
Refactoring legacy code
Test-driven maintenance
Test infrastructure
Test pyramid
Test code design pattern
Global test doubles
Test class hierarchies
Test data classes
ABAP Development Tools (ADT)
Agile development

View Full Table of Contents

Foreword
Preface
- Continuous Improvements
- Agile Methods
- Target Groups and Prerequisites
- Structure of the Book
  - Part I: Building a Test Infrastructure
  - Part II: Test-Oriented ABAP Design
  - Part III: Agile Development of a New Application
  - Part IV: Agile Methodology
  - Part V: Test-Oriented ABAP Tools
  - Appendices
- Information Boxes
- Limitations
- Acknowledgments
1 Introduction
- 1.1 Sustainability: Development and Maintenance with a Test Infrastructure
- 1.2 Agility: Practices of Agile Software Engineering
- 1.3 Efficiency: Compliance with Design Principles
  - 1.3.1 SOLID Principles
  - 1.3.2 FIRST Principles
- 1.4 Effectivity: Communication with Diagrams
- 1.5 Summary
PART I Building a Test Infrastructure
2 The Sample Application
- 2.1 Master Data Management
  - 2.1.1 Change Request
  - 2.1.2 Definition of a Master Data Model
- 2.2 User Interface
- 2.3 Backend
- 2.4 Summary
3 Code-Based Test Improvement
- 3.1 Introduction to the Test Code
  - 3.1.1 Defining a Test Class
  - 3.1.2 Implementing a Test Class
  - 3.1.3 ABAP Unit Log
  - 3.1.4 Diagrams
- 3.2 General Clean Code Principles
  - 3.2.1 Improvement Process
  - 3.2.2 Improving the Definition of the Test Class
  - 3.2.3 Improving the Implementation of the Test Class
  - 3.2.4 Diagrams
- 3.3 Test-Oriented Clean Code Principles
  - 3.3.1 Improvement Process
  - 3.3.2 Improving the Implementation of the Test Class
  - 3.3.3 Diagrams
- 3.4 Summary
4 Design-Based Test Improvement
- 4.1 Base Classes of Test Classes
  - 4.1.1 Improvement Process
  - 4.1.2 Extracting a Base Class from a Test Class
  - 4.1.3 Diagrams
- 4.2 Usage of Help Classes by Test Classes
  - 4.2.1 Improvement Process
  - 4.2.2 Design Patterns for Classes
  - 4.2.3 Defining and Using the Test Data Class
  - 4.2.4 Diagrams
- 4.3 Summary
5 Robust Integration Test
- 5.1 Improvement Process
- 5.2 Independence of Test Methods
  - 5.2.1 Test Data Container
  - 5.2.2 Singleton Design Pattern
- 5.3 Repeatability of Test Methods
  - 5.3.1 Automated Test Setup
  - 5.3.2 Help Methods for Test Class
  - 5.3.3 Diagrams
- 5.4 Summary
6 Minimizing Dependencies
- 6.1 Simplification of Use
  - 6.1.1 Improvement Process
  - 6.1.2 Simplifying the Productive API
  - 6.1.3 Access to the Test Data Container
  - 6.1.4 Delegating Test Classes
  - 6.1.5 Diagrams
- 6.2 Segregation of Use
  - 6.2.1 Improvement Process
  - 6.2.2 Nested Interfaces
  - 6.2.3 Diagrams
- 6.3 Independence of Creations
  - 6.3.1 Improvement Process
  - 6.3.2 Defining a Factory
  - 6.3.3 Implementing a Factory
  - 6.3.4 Diagrams
- 6.4 Independence of Extensions
  - 6.4.1 Improvement Process
  - 6.4.2 Abstract Superclass for All Entities
  - 6.4.3 Concrete Subclass for Flight Connections
- 6.5 Summary
7 Isolated Component Test
- 7.1 Transforming the Integration Test
  - 7.1.1 Improvement Process
  - 7.1.2 Isolation with a Governance API Test Double
  - 7.1.3 Configuring the Governance API Test Double
  - 7.1.4 Diagrams
- 7.2 Scaling with a Test Language
  - 7.2.1 Improvement Process
  - 7.2.2 State of an Entity
  - 7.2.3 Test Method: Unsaved Changes
  - 7.2.4 Test Method: Changes to a New Entity Type
  - 7.2.5 Test Method: Contained Changes
- 7.3 Test-Driven Development
  - 7.3.1 Test Class for Highlighting Deletions
  - 7.3.2 Diagrams
- 7.4 Liskov Substitution Principle
  - 7.4.1 Violation
  - 7.4.2 Compliance
- 7.5 Summary
8 Redesign with Unit Tests
- 8.1 Object-Oriented API for Entities
  - 8.1.1 Entity Type Class
  - 8.1.2 Selection Class
  - 8.1.3 Entity Set Class
  - 8.1.4 Entity API Class
- 8.2 Highlighting Changes as an Independent Component
  - 8.2.1 Highlight Changes Interface
  - 8.2.2 Highlight Changes Class
  - 8.2.3 Calculation Method for Entity Nodes
  - 8.2.4 Calculation Method for Entity Trees
  - 8.2.5 Using the Highlight Changes Class
- 8.3 Tests for the Highlight Changes Class
  - 8.3.1 Unit Tests
  - 8.3.2 Component Tests
- 8.4 Summary
PART II Test-Oriented ABAP Design
9 Designing Methods
- 9.1 Rules for Implementing Methods
  - 9.1.1 Commenting
  - 9.1.2 Formatting
- 9.2 Rules for Method Signatures
  - 9.2.1 Simple Example of Improving Method Signatures
  - 9.2.2 Compacting Method Signatures
  - 9.2.3 Advanced Example of Improving Method Signatures
- 9.3 Summary
10 Designing Classes
- 10.1 Creation of an Object by Its Class
  - 10.1.1 Creation Methods
  - 10.1.2 Testability of the Constructor
- 10.2 Creation of an Object by a Factory Class
  - 10.2.1 Creation without a Factory
  - 10.2.2 Creation with a Concrete Factory
  - 10.2.3 Creation with an Abstract Factory
- 10.3 Types of Dependencies between Classes
  - 10.3.1 Internal Dependencies
  - 10.3.2 External Dependencies
- 10.4 Interfaces of a Class
  - 10.4.1 Authorization-Specific Interfaces
  - 10.4.2 Role-Specific Interfaces
  - 10.4.3 Interface Principles
- 10.5 Levels of Abstraction within a Class
  - 10.5.1 Entity Set Class with Tables
  - 10.5.2 Entity Set Class with Objects
  - 10.5.3 Efficiency
- 10.6 Catalog Design Pattern
- 10.7 Cohesion
  - 10.7.1 Component Graph
  - 10.7.2 Horizontal Split of a Class
  - 10.7.3 Vertical Split of a Class
  - 10.7.4 Example of the Split of a Class
- 10.8 Summary
11 Designing Packages
- 11.1 Package Concept
  - 11.1.1 Visibility
  - 11.1.2 Package Interfaces
  - 11.1.3 Use Accesses
- 11.2 Product Packages
- 11.3 Test Packages
  - 11.3.1 Transport Layers
  - 11.3.2 Shortening of Note Chains
- 11.4 Summary
12 Test Cases
- 12.1 Test Design
  - 12.1.1 Parameter-Oriented Testing
  - 12.1.2 State-Oriented Testing
- 12.2 Test Pyramid
  - 12.2.1 Further Development of Legacy Code
  - 12.2.2 New Development
- 12.3 Test Coverage
  - 12.3.1 Responsibilities of the Test Types
  - 12.3.2 Completion of Test Coverage
- 12.4 Summary
13 Test Doubles
- 13.1 Advantages of Test Doubles
  - 13.1.1 Dependencies of a Test
  - 13.1.2 Verifying the Behavior of a Method
- 13.2 Specifying Test Doubles
  - 13.2.1 Test Double Types
  - 13.2.2 Using Test Doubles
- 13.3 Designing Test Doubles
  - 13.3.1 Interface and Subclass Doubles
  - 13.3.2 Proxy Doubles
  - 13.3.3 Changes to the Product Design in Favor of Testability
- 13.4 Injecting Test Doubles
  - 13.4.1 Injection Mechanisms Offered by the Class under Test
  - 13.4.2 Injection Mechanisms Enabled by the Class under Test
  - 13.4.3 Injection Mechanisms Enabled by a Depended-on Singleton Class
  - 13.4.4 Injection Mechanisms Enabled by a Static Factory
  - 13.4.5 Injection Mechanisms Enabled by a Singleton Factory
  - 13.4.6 Injection Mechanisms Enabled by an Abstract Factory
- 13.5 Summary
14 Global Test Doubles
- 14.1 Test Double for a Method
  - 14.1.1 Double Class with Many Creation Methods
  - 14.1.2 Double Class with One Creation Method
- 14.2 Test Double for Two Methods
  - 14.2.1 Definition and Implementation of the Test Double Class
  - 14.2.2 Definition and Implementation of the Test Class
- 14.3 Method Doubles and Their Combinations
  - 14.3.1 Cohesion of a Double Class
  - 14.3.2 Decorator Double Class
- 14.4 Globalizing Test Doubles
- 14.5 Designing Global Test Doubles
- 14.6 Adapting the Design of Global Test Doubles
  - 14.6.1 Job Interface
  - 14.6.2 Global Job Double Class
  - 14.6.3 Test Class for a Job User Class
- 14.7 Summary
15 Test Classes
- 15.1 ABAP Unit Test Framework
- 15.2 Local Test Classes
- 15.3 Design Patterns for Test Classes
  - 15.3.1 Given-When-Then Design Pattern
  - 15.3.2 Test Class Design Pattern
- 15.4 Test Class Hierarchies
- 15.5 Global Test Classes
- 15.6 Summary
16 Test Data
- 16.1 Test Data Container
  - 16.1.1 Using Test Data Containers in ABAP Unit
  - 16.1.2 Testing with and without Test Data Containers
- 16.2 Test Data Objects
- 16.3 Summary
17 Test Infrastructures
- 17.1 Components of Test Infrastructures
- 17.2 Application Scenarios for a Global Test Infrastructure
  - 17.2.1 Component Tests
  - 17.2.2 Integration Tests
- 17.3 Development Processes Using a Test Infrastructure
  - 17.3.1 Developing an API for Legacy Components
  - 17.3.2 Cross-Team Test Infrastructure
- 17.4 Summary
PART III Agile Development of a New Application
18 Preparation for Test-Driven Development
- 18.1 Specification of the Sample Application
- 18.2 Architecture and Design of the Sample Application
  - 18.2.1 Package Structure
  - 18.2.2 Data Model
  - 18.2.3 Object Model
- 18.3 Test Strategy for the Sample Application
  - 18.3.1 Acceptance Tests
  - 18.3.2 Process Component Tests
  - 18.3.3 Model Component Tests
  - 18.3.4 Access Integration Tests
- 18.4 Skeleton of the Sample Application
  - 18.4.1 All Components
  - 18.4.2 Model Component
  - 18.4.3 External Factory Class
  - 18.4.4 Internal Factory Class
  - 18.4.5 API Class
  - 18.4.6 Test Data Class
  - 18.4.7 Base Class for Component Tests
- 18.5 Summary
19 Test-Driven Development
- 19.1 Acceptance Test-Driven Development
  - 19.1.1 Base Class for the Acceptance Tests
  - 19.1.2 Acceptance Test (Given and When Phase)
- 19.2 Component Test-Driven Development
  - 19.2.1 Component Test Class for the Creation Process
  - 19.2.2 Global Double of the Contract Manager
  - 19.2.3 Development Tactics
- 19.3 Unit Test-Driven Development
- 19.4 Completion and Improvement of the First Acceptance Test
  - 19.4.1 Acceptance Test (Then Phase)
  - 19.4.2 Object-Based Comparison
  - 19.4.3 Refactoring of the Acceptance Test
- 19.5 Extension of the Acceptance Test Suite
  - 19.5.1 Test Development Strategy
  - 19.5.2 Component Test
  - 19.5.3 Integration Test
- 19.6 Summary
PART IV Agile Methodology
20 Scrum
- 20.1 Artifacts
  - 20.1.1 Product Backlog
  - 20.1.2 Ready Criteria
  - 20.1.3 Done Criteria
  - 20.1.4 Sprint Backlog
  - 20.1.5 Sprint Burndown Chart
  - 20.1.6 Release Burndown Chart
- 20.2 Roles
  - 20.2.1 Product Owner
  - 20.2.2 Scrum Master
  - 20.2.3 Team
- 20.3 Meetings
  - 20.3.1 Backlog Grooming
  - 20.3.2 Sprint Planning: Part 1
  - 20.3.3 Sprint Planning: Part 2
  - 20.3.4 Daily Scrum
  - 20.3.5 Sprint Review
  - 20.3.6 Sprint Retrospective
  - 20.3.7 Scrum Cycle
- 20.4 Characteristics
- 20.5 Summary
21 Agile Software Engineering
- 21.1 Refactoring
  - 21.1.1 Implementation
  - 21.1.2 Advantages and Disadvantages
  - 21.1.3 Differentiation
- 21.2 Test-Driven Development
  - 21.2.1 Implementation
  - 21.2.2 Advantages and Disadvantages
  - 21.2.3 Alternatives
- 21.3 Pair Programming
  - 21.3.1 Implementation
  - 21.3.2 Advantages and Disadvantages
  - 21.3.3 Alternatives
- 21.4 Walking Skeleton
  - 21.4.1 Implementation
  - 21.4.2 Advantages and Disadvantages
- 21.5 Shared Code Ownership
  - 21.5.1 Implementation
  - 21.5.2 Advantages and Disadvantages
  - 21.5.3 Alternatives
- 21.6 Continuous Integration
  - 21.6.1 Continuous Integration with ABAP
  - 21.6.2 Local Change
- 21.7 Summary
22 Lean Development Model
- 22.1 Basics
- 22.2 Implementing Lean Principles with Agile Software Engineering
  - 22.2.1 Refactoring
  - 22.2.2 Test-Driven Development
  - 22.2.3 Pair Programming
  - 22.2.4 Walking Skeleton
  - 22.2.5 Shared Code Ownership
- 22.3 Test Infrastructure
- 22.4 Summary
23 Team Development
- 23.1 Sustainable Learning
- 23.2 Learning Gaps
  - 23.2.1 No Unit Tests
  - 23.2.2 Long Methods
  - 23.2.3 Learning Plan
- 23.3 Agile Coaching
  - 23.3.1 Implementation
  - 23.3.2 Advantages and Disadvantages
- 23.4 Network for Agile Coaching
- 23.5 Summary
24 Backlog Development
- 24.1 Design Thinking
  - 24.1.1 Understand
  - 24.1.2 Observe
  - 24.1.3 Define Point of View
  - 24.1.4 Ideate
  - 24.1.5 Prototype
  - 24.1.6 Test
- 24.2 User Story Mapping
  - 24.2.1 Structure of a User Story Map
  - 24.2.2 Review of a User Story Map
- 24.3 Summary
25 Product Development
- 25.1 Sustainable Development
  - 25.1.1 Maintaining Productivity
  - 25.1.2 Improving Productivity
- 25.2 Development Strategies for Legacy Code
  - 25.2.1 Characterization
  - 25.2.2 Transformation
- 25.3 Development Strategies for New Code
- 25.4 Summary
PART V Test-Oriented ABAP Tools
26 ABAP Unit
- 26.1 CL_ABAP_UNIT_ASSERT Class
  - 26.1.1 Methods
  - 26.1.2 Parameters
  - 26.1.3 Constraints
- 26.2 Execution of Tests
  - 26.2.1 Static Basics of Test Execution
  - 26.2.2 Dynamic Basics of Test Execution
  - 26.2.3 Test Relations
- 26.3 Development Objects
- 26.4 Summary
27 ABAP Development Tools
- 27.1 Introduction
  - 27.1.1 SAP Help
  - 27.1.2 Creating a Project
  - 27.1.3 Creating a Product Class
- 27.2 Test-Driven Development with ABAP Development Tools
  - 27.2.1 Authority Check as Test Stub
  - 27.2.2 Authority Check as Test Spy
  - 27.2.3 Authority Check as Mock Object
- 27.3 Summary
28 ABAP Tools for Test Isolation
- 28.1 Sample Class
- 28.2 Open SQL Test Double Framework
- 28.3 Test Seams
- 28.4 ABAP Test Double Framework
- 28.5 Summary
Appendices
- A Naming Conventions for ABAP Code
  - A.1 Classes
  - A.2 Storages
  - A.3 Methods
- B Bibliography
- C The Author
Index

ℹ️ How to purchase this book?

This product has a special price upon request. You can start your order or clarify any doubts using the Contact for Price button on the page.

We have also prepared a step-by-step guide to explain how to easily request your quote.

Read the guide here →

Disclaimer

SAP, other SAP products and services mentioned herein as well as their respective logos are trademarks or registered trademarks of SAP SE (or an SAP affiliate company) in Germany and other countries. Our Company is not affiliated to SAP SE or any of its affiliated companies including but not limited to: Sybase, Business Objects, Hybris, Ariba and SuccessFactors. All other names, brands, logos, etc. are registered trade or service marks of their respective owners.

Home > SAP Books > English Books > Test-Driven Development with ABAP Objects

Test-Driven Development with ABAP Objects

Name: Test-Driven Development with ABAP Objects
Brand: SAP
SKU: BOOK-SAPPRESS-EBOOK-2019-9781493218332
Availability: InStock

Warranty

Receive the product you were expecting or we will refund your money

Would you like to see a sample of the course or book?

If you need a sample of the course or book, request it in the chat below and we will be happy to provide it to you.

1 installment of $0.00 USD without interest		Total $0.00 USD
2 installments of $0.00 USD without interest		Total $0.00 USD
3 installments of $0.00 USD without interest		Total $0.00 USD
4 installments of $0.00 USD without interest		Total $0.00 USD
5 installments of $0.00 USD without interest		Total $0.00 USD
6 installments of $0.00 USD without interest		Total $0.00 USD

Test-Driven Development with ABAP Objects

You'll learn about:

Key Highlights:

ℹ️ How to purchase this book?

Disclaimer

Test-Driven Development with ABAP Objects

Related products