Can we meaningfully use `await` on the FuncUnit object

by

Summary

The question revolves around whether the FuncUnit object can be used with await to guarantee that a function is executed after all previous FuncUnit actions have completed. The FuncUnit object has a then method, which suggests it could be used with await, but its compatibility with Promises is unclear.

Root Cause

The root cause of the uncertainty lies in the FuncUnit object’s implementation of the then method, which does not fully satisfy the conditions required by Promises. The key issues are:

  • The then method does not handle errors as required by the Promises/A+ specification
  • The FuncUnit object does not provide a way to check if an action has completed, making it difficult to determine when to execute the next action

Why This Happens in Real Systems

This issue occurs in real systems because:

  • FuncUnit is designed to work with a specific set of actions and may not be fully compatible with Promises
  • The then method is implemented in a way that is not consistent with the Promises/A+ specification
  • Developers may not fully understand the limitations of the FuncUnit object and its compatibility with Promises

Real-World Impact

The real-world impact of this issue is:

  • Unpredictable behavior: Using await with the FuncUnit object may result in unpredictable behavior, such as functions being executed before previous actions have completed
  • Difficulty debugging: The lack of clear error handling and the unpredictable behavior of the FuncUnit object can make it difficult to debug issues
  • Inconsistent results: The behavior of the FuncUnit object may vary depending on the browser or environment, leading to inconsistent results

Example or Code

// Example of using FuncUnit with then method
F('.someClass').visible().click().then(someFunction);

// Example of using await with FuncUnit (may not work as expected)
await F('.someClass').visible().click();
someFunction();

How Senior Engineers Fix It

Senior engineers fix this issue by:

  • Using the then method: Instead of using await, senior engineers use the then method to ensure that functions are executed after previous actions have completed
  • Implementing custom error handling: Senior engineers implement custom error handling to ensure that errors are properly handled and debugged
  • Using Promises-compatible libraries: Senior engineers use libraries that are compatible with Promises, such as funcunit-as-promised, to ensure that the FuncUnit object behaves as expected

Why Juniors Miss It

Juniors may miss this issue because:

  • Lack of understanding of Promises: Juniors may not fully understand the Promises/A+ specification and the requirements for a then method to be compatible with Promises
  • Overreliance on await: Juniors may rely too heavily on await and not consider the limitations of the FuncUnit object
  • Insufficient testing: Juniors may not thoroughly test their code to ensure that it behaves as expected in different browsers and environments

Leave a Comment