PF-WEBTEST

Katalon Best Practices Guide

Test Organization

1. Folder Structure:

• Organize test cases and test suites logically in a folder structure that reflects your application's architecture.
• Consider grouping tests by module, feature, or user journey for easy navigation and maintenance.
• Maintain a consistent naming convention for folders to ensure clarity and uniformity across projects.

2. Modularization:

• Break down tests into smaller, reusable modules to promote code reusability and maintainability.
• Create common libraries or utility classes for frequently used functionalities like login, data manipulation, or assertions.
• Utilize Katalon's built-in support for reusable test artefacts such as Keywords and Custom Keywords.

3. Test Suites:

• Use test suites to organize and execute related test cases in batches.
• Group tests based on priority, functionality, or integration points to streamline execution and reporting.
• Regularly review and update test suites to reflect changes in application features or requirements.

Test Naming

1. Descriptive Names:

• Choose descriptive names that accurately reflect the purpose and functionality of each test case.
• Use clear and concise language to convey the intent of the test without ambiguity.
• Incorporate keywords or phrases that indicate the scope, action, and expected outcome of the test.

2. Consistency:

• Establish and follow a consistent naming convention across all test cases and test suites.
• Consider including prefixes or suffixes to categorize tests by type (e.g., UI, API, End-to-End) or functionality (e.g., Login, Checkout).
• Avoid using abbreviations or acronyms that may be ambiguous or unclear to other team members.

3. Readability:

• Prioritize readability by using camelCase, PascalCase, or snake_case formatting for test names.
• Break down complex test scenarios into smaller, sequential steps within the test case name for better comprehension.
• Include relevant context or information in the test name to aid troubleshooting and debugging efforts.

4. Test Scenario Format:

• Follow the Given-When-Then format to structure test case names and describe test scenarios effectively.
• Start each test case name with a clear indication of the initial context or precondition (Given).
• Describe the action or event being tested in the middle part of the test case name (When).
• Conclude the test case name with the expected outcome or result (Then).

Objects Organization

1. Page Object Model (POM):

• Implement the Page Object Model design pattern to encapsulate web elements and their interactions within dedicated page classes.
• Create a separate page class for each unique page or component in your application.
• Define methods within page classes to represent common user actions (e.g., click, type, verify) and abstract away the underlying implementation details.

2. Object Repository:

• Organize objects into a hierarchical folder structure that reflects the application's UI hierarchy.
• Create folders for each page or component, following the naming convention of Page/action/name.
• For example, if there is a "Create" button on the "Page", you would save its object in the folder structure: Page/create/button.
• Use clear and descriptive names for object identifiers within each folder to facilitate easy identification and maintenance.
• Regularly review and update the Object Repository to reflect changes in the application's UI or functionality.
• Remove redundant or obsolete objects to declutter the repository and improve performance.
• Document any changes or updates made to objects to ensure transparency and collaboration among team members.

3. Regular Maintenance:

• Regularly review and update the Object Repository to reflect changes in the application's UI or functionality.
• Remove redundant or obsolete objects to declutter the repository and improve performance.
• Document any changes or updates made to objects to ensure transparency and collaboration among team members.

By following this approach, you ensure that objects are organized logically and intuitively, making them easy to locate, maintain, and reuse across your test automation projects.