
Refactoring is a crucial practice in software development that helps to improve the design of existing code without altering its functional behavior. In the refactoring process, unit tests play a vital role as they validate that the functionality remains consistent pre and post-refactoring. Let's dive into a real-world ABAP code refactoring scenario, placing emphasis on the importance of unit tests.

# Before refactoring: Understanding the original code and motivation

In our previous posts, [Real world example of ABAP unit testing](/blog/real-world-example-of-abap-unit-testing), the original code consisted of a class zcl_airline_capacity with several methods calculating various capacities for an airline. Each of these methods executed its own database SELECT operation to fetch the needed data, and the test class, as well as the execution code, invoked these methods independently. This design, while functional, was ripe for refactoring to improve efficiency and readability.

Refactoring plays a critical role in sustaining the longevity and health of code. The process of refactoring involves revising existing code without changing its external behavior. The primary goal is to improve the internal structure and overall readability of the system, which in turn accelerates future development speed and simplifies maintenance.

# The safety net: Unit testing before refactoring

Before initiating any refactoring activities, it's critical to have a set of unit tests in place to act as a safety net. The initial code provided a test class ltc_airline_capacity_tests that confirmed the proper function of each method. Running these tests and ensuring all are passing is the first crucial step before starting to refactor.

# After refactoring: Embracing improved design

The refactored code introduces several key improvements to the design:

1. Data structuring: The introduction of the s_sflight structured data type provided a more organized approach to handling the related flight fields.
2. Interface use: By implementing the zif_airline_capacity interface in zcl_airline_capacity class, the code structure became more flexible and provided clear visibility of the class's capabilities.
3. Data fetching: A newly added get_data method fetched all the required data at once, significantly reducing the number of database accesses and improving the efficiency of the code.
4. Test class: The refactored test class fetched all required data once during the setup phase, improving both performance and readability.


> ### Ready to level up your unit testing? 
> With Nuve Platform, refactor code at your own pace without disruptions. Check out our plans and [start your journey today](/pricing).

# 

```abap
REPORT zairline_info.

*********************************************************************************************
* Functional code
*********************************************************************************************
TYPES: BEGIN OF s_sflight,
         mandt      TYPE s_mandt,
         carrid     TYPE s_carr_id,
         connid     TYPE s_conn_id,
         fldate     TYPE s_date,
         price      TYPE s_price,
         currency   TYPE s_currcode,
         planetype  TYPE s_planetye,
         seatsmax   TYPE s_seatsmax,
         seatsocc   TYPE s_seatsocc,
         paymentsum TYPE s_sum,
         seatsmax_b TYPE s_smax_b,
         seatsocc_b TYPE s_socc_b,
         seatsmax_f TYPE s_smax_f,
         seatsocc_f TYPE s_socc_f,
       END OF s_sflight.

TYPES: t_sflight TYPE TABLE OF s_sflight.

INTERFACE zif_airline_capacity.
  METHODS:
    get_data
      IMPORTING
        iv_carrid TYPE s_sflight-carrid,
    get_total_capacity
      RETURNING
        VALUE(rv_total_capacity) TYPE i,
    get_used_capacity
      RETURNING
        VALUE(rv_used_capacity) TYPE i,
    get_available_capacity
      RETURNING
        VALUE(rv_available_capacity) TYPE i.

ENDINTERFACE.

CLASS zcl_airline_capacity DEFINITION.
  PUBLIC SECTION.
    INTERFACES: zif_airline_capacity.
  PROTECTED SECTION.
    DATA: lt_sflight_data TYPE t_sflight,
          ls_sflight_data TYPE s_sflight.
ENDCLASS.

CLASS zcl_airline_capacity IMPLEMENTATION.
  METHOD zif_airline_capacity~get_data.
    SELECT *
      INTO TABLE @lt_sflight_data
      FROM sflight
      WHERE carrid = @iv_carrid.

  ENDMETHOD.

  METHOD zif_airline_capacity~get_available_capacity.
    LOOP AT lt_sflight_data INTO ls_sflight_data.
      rv_available_capacity = rv_available_capacity + ( ls_sflight_data-seatsmax + ls_sflight_data-seatsmax_b + ls_sflight_data-seatsmax_f - ls_sflight_data-seatsocc - ls_sflight_data-seatsocc_b - ls_sflight_data-seatsocc_f ).

    ENDLOOP.

  ENDMETHOD.

  METHOD zif_airline_capacity~get_used_capacity.
    LOOP AT lt_sflight_data INTO ls_sflight_data.
      rv_used_capacity = rv_used_capacity + ( ls_sflight_data-seatsocc + ls_sflight_data-seatsocc_b + ls_sflight_data-seatsocc_f ).

    ENDLOOP.

  ENDMETHOD.

  METHOD zif_airline_capacity~get_total_capacity.
    LOOP AT lt_sflight_data INTO ls_sflight_data.
      rv_total_capacity = rv_total_capacity + ( ls_sflight_data-seatsmax + ls_sflight_data-seatsmax_b + ls_sflight_data-seatsmax_f ).

    ENDLOOP.

  ENDMETHOD.

ENDCLASS.

*********************************************************************************************
* Test Class
*********************************************************************************************
CLASS ltc_airline_capacity_tests DEFINITION FOR TESTING RISK LEVEL HARMLESS DURATION SHORT.
  PRIVATE SECTION.
    DATA: lo_airline_capacity TYPE REF TO zcl_airline_capacity.

    METHODS:
      setup,
      test_get_available_capacity FOR TESTING,
      test_get_used_capacity FOR TESTING,
      test_get_total_capacity FOR TESTING,
      test_capacity_relationship FOR TESTING.

ENDCLASS.

CLASS ltc_airline_capacity_tests IMPLEMENTATION.
  METHOD setup.
    CREATE OBJECT lo_airline_capacity.
    lo_airline_capacity->zif_airline_capacity~get_data( 'AA' ).

  ENDMETHOD.

  METHOD test_get_available_capacity.
    DATA: lv_available_capacity TYPE i.

    lv_available_capacity = lo_airline_capacity->zif_airline_capacity~get_available_capacity( ).

    cl_abap_unit_assert=>assert_not_initial(
      act = lv_available_capacity
      msg = 'Available capacity for the airline should not be initial'
    ).

  ENDMETHOD.

  METHOD test_get_used_capacity.
    DATA: lv_used_capacity TYPE i.

    lv_used_capacity = lo_airline_capacity->zif_airline_capacity~get_used_capacity( ).

    cl_abap_unit_assert=>assert_not_initial(
      act = lv_used_capacity
      msg = 'Used capacity for the airline should not be initial'
    ).

  ENDMETHOD.

  METHOD test_get_total_capacity.
    DATA: lv_total_capacity TYPE i.

    lv_total_capacity = lo_airline_capacity->zif_airline_capacity~get_total_capacity( ).

    cl_abap_unit_assert=>assert_not_initial(
      act = lv_total_capacity
      msg = 'Total capacity for the airline should not be initial'
    ).

  ENDMETHOD.

  METHOD test_capacity_relationship.
    DATA: lv_total_capacity     TYPE i,
          lv_available_capacity TYPE i,
          lv_used_capacity      TYPE i.

    lv_total_capacity = lo_airline_capacity->zif_airline_capacity~get_total_capacity( ).
    lv_available_capacity = lo_airline_capacity->zif_airline_capacity~get_available_capacity( ).
    lv_used_capacity = lo_airline_capacity->zif_airline_capacity~get_used_capacity( ).

    cl_abap_unit_assert=>assert_equals(
      act = lv_total_capacity
      exp = lv_available_capacity + lv_used_capacity
      msg = 'Total capacity should be equal to the sum of available and used capacity'
    ).

  ENDMETHOD.

ENDCLASS.

*********************************************************************************************
* Execute dode
*********************************************************************************************
START-OF-SELECTION.

  DATA: lo_airline_capacity TYPE REF TO zcl_airline_capacity,
        available_capacity  TYPE i,
        used_capacity       TYPE i,
        total_capacity      TYPE i.

  CREATE OBJECT lo_airline_capacity.
  lo_airline_capacity->zif_airline_capacity~get_data( 'AA' ).

  available_capacity = lo_airline_capacity->zif_airline_capacity~get_available_capacity( ).
  used_capacity = lo_airline_capacity->zif_airline_capacity~get_used_capacity( ).
  total_capacity = lo_airline_capacity->zif_airline_capacity~get_total_capacity( ).

  WRITE: / 'The available capacity for airline AA is:', available_capacity.
  WRITE: / 'The used capacity for airline AA is:     ', used_capacity.
  WRITE: / 'The total capacity for airline AA is:    ', total_capacity.
```


# Revalidating functionality: Running unit tests after refactoring

Post-refactoring, the unit tests were run once more. This step is crucial to confirm that the code changes haven't inadvertently altered the functionality of the application. In our case, all tests passed, affirming the success of the refactoring process.

# Key takeaways: The synergy of unit tests and refactoring

This post illustrates the critical role unit tests play in the refactoring process. By providing a safety net, unit tests facilitate fearless refactoring, allowing developers to focus on improving code design and efficiency without worrying about unintentionally breaking the functionality. So, before you embark on your next refactoring journey, remember to harness the power of unit tests for a smoother and more reliable process. 

Happy testing (and refactoring)!


Achieve successful code refactoring with unit tests

Unlock the power of unit tests for successful code refactoring in this deep dive into a real-world ABAP example.

The role of unit testing in ABAP code refactoring

Related posts

Principles and practices of ABAP unit testing

Real world example of ABAP unit testing

Reducing bugs, again