[Part 5]Functions and Modules – Writing Reusable and Modular TypeScript QA Code

Introduction

Functions and modules improve test script maintainability and scalability by making code reusable. This module covers function creation, modularization, and npm integration in TypeScript for test automation.

---

Lesson 1: Defining and Calling Functions in TypeScript

Concept:
Functions enable reusable logic in test scripts, reducing redundancy and improving maintainability.

Key Topics:

• Function Declaration: Writing named functions.
• Function Expressions: Assigning functions to variables.
• Arrow Functions: Using concise ES6+ syntax.
• Calling Functions: Executing functions in test automation.

Example:

function validateTestResult(actual: string, expected: string): string {
    return actual === expected ? "Test Passed" : "Test Failed";
}
console.log(validateTestResult("Success", "Success"));

Pro Tip: Always define function return types for better type safety.

---

Lesson 2: Function Parameters and Return Types

Concept:
Functions can accept parameters and return values, making them flexible for different test cases.

Key Topics:

• Parameter Types: Ensuring function inputs are correctly typed.
• Optional Parameters: Allowing parameters to be optional.
• Rest Parameters: Handling dynamic arguments.
• Return Types: Defining expected function outputs.

Example:

function generateTestReport(testName: string, status: string = "Pending"): string {
    return `Test: ${testName}, Status: ${status}`;
}
console.log(generateTestReport("Login", "Passed"));

Pro Tip: Use default parameters to avoid undefined function arguments.

---

Lesson 3: Working with TypeScript Modules and npm

Concept:
Modules allow breaking down test scripts into reusable components.

Key Topics:

• Exporting and Importing Modules: Sharing reusable code across files.
• Using npm Packages: Installing and managing dependencies.
• Modularizing Test Scripts: Structuring code into logical components.

Example:

// testUtils.ts
export function isEqual(a: any, b: any): boolean {
    return a === b;
}

// main.ts
import { isEqual } from "./testUtils";
console.log(isEqual(10, 10));

Pro Tip: Keep reusable test utilities in a /utils folder for better project organization.

---

Lesson 4: Creating and Organizing TypeScript Modules for Test Automation

Concept:
Modular test automation improves script organization and scalability.

Key Topics:

• Structuring a Test Automation Project: Using folders and naming conventions.
• Encapsulating Test Functions: Grouping related functions in modules.
• Best Practices for Module Reusability: Ensuring test components are adaptable.

Example:

// testFunctions.ts
export function checkStatus(status: string): string {
    return status === "Passed" ? "✅" : "❌";
}

Importing the module:

import { checkStatus } from "./testFunctions";
console.log(checkStatus("Passed"));

Pro Tip: Follow a standardized module structure for easier collaboration.

---

Conclusion

This module introduced TypeScript functions and modules, enabling the creation of scalable, reusable, and maintainable test scripts.

Key Takeaways:

• Functions improve code reuse and maintainability in automation scripts.
• Typed parameters and return values enhance function reliability.
• TypeScript modules allow logical separation of test scripts.
• npm simplifies dependency management for automation projects.

What’s Next?
In the next module, we will explore Error Handling and Exception Handling in TypeScript for Robustness, covering techniques to catch, log, and handle errors in test automation scripts.

Visit us at Testamplify | X | Instagram | LinkedIn