A system for generating test scenarios using offline modeling, permutations and method thereof

Abstract

The invention relates to a system (100) for generating test scenarios using offline modeling and permutations, wherein the system (100) comprises a Quality Assurance (QA) application (101) necessitating authentication of one or more users to create a new project, comprising a scraper (102) for scraping the attributes of one or more User Interface (UI) elements within applications, a profiler (103) for constructing a centralized offline model of the application under test and generating the test case files using a test case engine (TCE) (104), an Automation Framework (AF) (105) for generating customized and tailored test automation scripts and an Artificial Intelligence (AI) (106) for automating the resolution of the issues encountered during the testing process. The present invention also discloses a method (200) for generating test scenarios using offline modeling and permutations.

Description

A system for generating test scenarios using offline modeling, permutations and method thereofPreamble to the Description

[0001] The following specification particularly describes the invention and the manner in which it is to be performed:DESCRIPTION OF THE INVENTIONTechnical field of the invention

[0002] The present invention relates to a system for generating test scenarios using offline modeling and permutations. The present invention particularly relates to creating an offline model of the application under test that utilizes the application profiling thus created to record and generate test scenarios and primarily focuses on the intelligent automation of software testing. The present invention further discloses a method for generating test scenarios using offline modeling and permutations.Background of the invention

[0003] In the current digital marketplace, a demand for automated testing has grown substantially to expedite product updates. Automation testing plays a pivotal role in modern software development, offering faster, more efficient, and cost-effective methods to ensure software product quality. Various approaches are available in the domain of automation testing.

[0004] One such approach to automation testing is the "Record and Playback approach," where user actions are captured and replicated to automate tests on the application. Thismethod is best suited for relatively simple applications with straightforward workflows and minimal dynamism, as it requires the application to be fully prepared without any test blockers. Another approach is the "Keyword-Driven" testing methodology, which separates test logic from test data using a set of keywords or actions to abstract test steps. This clear separation enhances test reusability and maintainability, making it more effective for complex applications with multiple workflows, diverse test scenarios, and significant variations in data sets. However, this approach is more complex to set up.

[0005] Several organizations have explored the use of Natural Language Processing (NLP) to generate test cases from requirements documents. However, this approach requires standardized requirements documents, posing certain challenges. Despite these obstacles, automating product testing remains essential for achieving faster product updates and reducing time to market, not only for system and integration testing but also for in-sprint testing. To ensure smooth and effective automation testing, it is essential to start early in the development process. By integrating automation testing with inputs such as wireframes or Swagger documents, which are also used by developers, the process can seamlessly become a part of development. Early adoption of automation testing facilitates early issue detection, leading to timely resolutions and ultimately improving the overall software quality through effective testing.

[0006] Currently, a significant gap exists in establishing mechanisms for automating testing without the application being fully prepared and leveraging the same inputs used by development teams for in-sprint test automation hampers the efficiency and effectiveness of the automation process.

[0007] For instance, the Patent Application No. US10642721B2 titled “Generation of automated testing scripts by converting manual test cases” discloses an automated testing script generation system. The system involves receiving a context file, a test scenario, and a selected automation tool via a user interface. The context file contains an object map comprising objects associated with components on a display page. The test scenario describes a specific test case involving an intended interaction with a component on the display page. The system correlates the intended interaction with the corresponding objectin the object map, processes them using an Artificial Intelligence (Al) model, determines a script template, applies the script template to generate an automated testing script suitable for the selected automation tool, and executes the script to test the functionality of the display page.

[0008] The Patent Application No. US10417113B1 titled “System, method, and computer program for web testing and automation offline storage and analysis” discloses a system, method, and computer program product for web testing and automation offline storage and analysis. The system monitors an automated testing flow of a system being tested. Upon receiving an instruction, the system captures a complete snapshot of the system under test, including its appearance, digital assets used in the automated testing flow, and the current code associated with the testing flow. This allows a tester to have full client-side functionality of the system offline, enabling offline analysis and testing.

[0009] The Patent Application No. CN115617688A titled “Interface testing method and system based on use case automation” discloses an interface testing method for software automation, specifically focused on case automation. The method involves analyzing testing steps based on the desired function and establishing an automatic testing case framework accordingly. It further includes acquiring other automatic test cases with similar test steps and extracting interface parameters related to those steps. By incorporating these interface parameters into the existing framework, the method enables efficient function testing by leveraging parameter interfaces from other test cases, eliminating the need for repeated configuration file loading.

[0010] As a result, there is a requirement for automation testing methods that can efficiently, time-effectively, and productively record user actions.Summary of the invention

[0011] The present invention addresses the limitations of the prior art by introducing a system for offline profiling of the application under test. The present invention offers a straightforward solution to the problem of capturing test cases step by step. The present invention involves generating test scenarios through offline modeling and permutations,creating a "virtual version" of the application known as the "offline model" even before the application is fully developed. The present invention enables early testing during the development process, even before any code is written, resulting in reduced testing cycle time and facilitating in-sprint automation.

[0012] The present invention discloses a comprehensive system that leverages offline modeling and permutations to generate test scenarios. The system comprises several components, including a scraper responsible for extracting User Interface (UI) element attributes to facilitate automation. Further, the system incorporates a profiler to construct a centralized offline model of the application under test and generate test case files through the Test Case Engine (TCE). Additionally, the system features an Automation Framework (AF) designed to create tailored test automation scripts for multiple programming languages. Moreover, Artificial Intelligence (Al) is integrated to automate issue resolution during testing.

[0013] The present invention introduces an innovative offline model that acts as a comprehensive representation of the application, encompassing UI elements, (Application Programming Interface (API) attributes, and database attributes. This virtual environment enables testers to record user actions, execute API calls, and perform database queries. Moreover, it allows remote users to work on the model without requiring a direct connection to the actual application.

[0014] The present invention further discloses a method for generating test scenarios through offline modeling and permutations. The method entails scraping the attributes of one or more user interface (UI) elements from applications using a scraper to facilitate automation. Further, the method facilitates the selection of specific automation modes, including web automation, desktop automation, mobile automation, API automation, or load test automation. This selection is achieved conveniently through a dropdown option for creating a new project. Subsequently, the method constructs a centralized offline model of the application under test using a profiler, which takes the comma-separated values (CSV) files generated by the scraper as input. The profiler then utilizes the test case engine (TCE) to generate multiple test case files.

[0015] Further, the method generates customized and tailored test automation scripts for one or more programming languages through the utilization of an Automation Framework (AF). The AF takes the test case files generated collaboratively by the algo profiler and the test case engine (TCE) as input. Additionally, the method automates issue resolution encountered during the testing process with the assistance of artificial intelligence. Furthermore, the method seamlessly integrates Artificial Intelligence (Al) that continuously monitors the testing process, provides valuable suggestions for improvement, and possesses the capability to automatically adapt test scripts in response to application changes. Additionally, it effectively handles wait times for network issues, ensuring the testing process remains reliable and efficient.

[0016] The present invention substantially reduces testing time, elevates test coverage, and fosters better collaboration among testers and developers by harnessing these innovative capabilities. The method emphasis on early testing and comprehensive automation holds the potential to revolutionize the efficiency and effectiveness of software testing, ultimately resulting in higher-quality software products.Brief Description of drawings

[0017] Figure 1 illustrates a block diagram of a system for generating test scenarios using offline modelling and permutations, in accordance with an embodiment of the present invention.

[0018] Figure 2 illustrates a flowchart of a method for generating test scenarios using offline modelling and permutations, in accordance with one embodiment of the present invention.

[0019] Figure 3 illustrates a flow diagram of the process of generating test scenarios using offline modelling and permutations, in accordance with one embodiment of the present invention.Detailed description of the invention

[0020] In order to more clearly and concisely describe and point out the subject matter of the claimed invention, the following definitions are provided for specific terms, which are used in the following written description.

[0021] The present invention relates to a system for generating test scenarios through offline modeling and permutations. The system entails creating an offline model of the application-under-test, encompassing UI elements, API attributes, and database attributes. This enables test automation even before the application under test is fully developed. The system offers a user-friendly, drag-and-drop interface to construct the application model and record user actions and interactions in the offline model. These actions are then translated into test scenarios, facilitating easy conversion into test scripts using Low-Code- No-Code techniques. Moreover, the system supports parameterized test data generation, extensive test coverage through permutations and combinations, and seamless collaboration among multiple users. This enhances test automation efficiency throughout the software development lifecycle.

[0022] Further, the present invention discloses a method for generating test scenarios through offline modeling and permutations. The method allows testing to commence early in the development process, even before the application under test is fully prepared. Further, the method eliminates the need for manual test case writing or recording user actions, resulting in a faster and more streamlined testing process. The method seamlessly integrates testing into the development workflow by utilizing wireframes or swagger documents, which are the same inputs employed by developers. By doing so, the method facilitates a smoother collaboration between testers and developers. Moreover, the method allows for the inclusion of Application Programming Interface (API) and database interactions, enabling comprehensive testing throughout the development stages. The method revolutionizes the testing process by enabling early testing, eliminating manual efforts, promoting seamless collaboration, and facilitating comprehensive testing in software development.

[0023] Figure 1 illustrates a block diagram of a system for generating test scenarios using offline modelling and permutations, in accordance with an embodiment of the presentinvention. The system (100) comprises a Quality Assurance (QA) application (101) necessitating authentication of one or more users to create a new project, for facilitating the execution of offline modeling and profiling of an application under test. Further, the Quality Assurance (QA) application (101)) comprises a scrapper (102) for scraping plurality of attributes of one or more User Interface (UI) elements within the application under test for facilitating automation. Further, the Quality Assurance (QA) application (101) comprises a profiler (103) for constructing a centralized offline model of the application under test and generating the test case files with the help of a test case engine (TCE) (104). Further, the Quality Assurance (QA) application (101) comprises an Automation Framework (AF) (105) for generating customized and tailored test automation scripts for one or more programming languages. Furthermore, the Quality Assurance (QA) application (101) comprises an Artificial Intelligence (Al) (106) for automating the resolution of the issues encountered during the testing process. In an embodiment, the system (100) employs a user-friendly, drag-and-drop interface to construct the application model and record user actions and interactions in the offline model. These actions are then translated into test scenarios, facilitating easy conversion into test scripts using Low-Code- No-Code techniques.

[0024] As an illustrative example, consider a scenario involving a development team tasked with creating an e-commerce website aimed at ensuring impeccable website functionality and delivering a superior user experience. Conventionally, the team would need to wait until the website is fully developed before initiating the testing phase. This customary approach might entail the creation of manual test cases or the recording of user interactions for subsequent testing purposes. However, with the introduction of the offline profiling methodology applied to the application under test, the testing process gains the ability to commence at an earlier stage. Through the utilization of wireframes and design documents, the testing team can initiate the development of automated test scripts even prior to the completion of the website's construction. As the development team progresses with the incorporation of features such as shopping cart functionality, the testing team can proactively possess automated tests that are aligned with the wireframes. These automated tests replicate user interactions, including activities such as item addition to the cart andprogressing through the checkout process. This early integration of automated testing equips the team to promptly identify and rectify potential issues in their nascent stages, consequently facilitating a streamlined development trajectory and culminating in a website that adheres to elevated quality standards. The gained efficiency stemming from the early commencement of testing guarantees the establishment of a more robust and usercentric e-commerce platform.

[0025] Moreover, the implementation of offline profiling serves to facilitate the integration of API testing by the testing team. As an illustrative instance, in the event that developers incorporate payment gateway APIs, the testing team can promptly devise automated tests to validate the accurate functioning of payment processing, thereby obviating the necessity to await the complete readiness of the entire website. By the time the website attains full development status, the testing team would have already established an extensive array of automated tests encompassing diverse features and functionalities. This all-encompassing methodology ensures the realization of a comprehensive and uninterrupted testing procedure across the entirety of the development cycle. As a consequence, the team is adept at swiftly identifying and mitigating issues during their nascent phases, thereby leading to an expedited and streamlined development trajectory.

[0026] As another illustrative embodiment, the system (100) finds applicability within a training portal framework, which functions as an integrated platform for the delivery and management of training programs. This comprehensive portal encompasses a web-based application facilitating learners' access to educational resources and the monitoring of their progress. Furthermore, the training portal incorporates a combination of servers, storage devices, and networking infrastructure to ensure the consistent and reliable availability of training materials. Nevertheless, the training platform may encounter various challenges, including login difficulties, fluctuations in user traffic, abrupt surges in load, and usability issues.

[0027] To surmount these limitations, the system (100) proficiently identifies and rectifies potential issues, ensuring the unblemished functioning of the platform and the delivery of a user-friendly experience. In this particular context, users possess the flexibility to crafttheir own test cases or opt for tests that are generated by the system based on the offline model of the application under scrutiny. This adaptable approach empowers users to undertake thorough testing, thus elevating the overall quality and usability of the training portal. Through the proactive management of potential issues, the system (100) contributes to fostering a seamless and successful experience for both learners and administrators utilizing the training portal.

[0028] FIG 2 illustrates a flowchart of a method generating test scenarios using offline modelling and permutations, in accordance with one embodiment of the present invention. The method (200) for generating test scenarios using offline modelling and permutations comprises the steps of scraping attributes of the one or more user interface (UI) elements within an application using the scrapper in step (201). In step (202), authentication is gained into the Quality Assurance (QA) application for creating a new project by the user to proceed with offline modeling and profiling. In an embodiment, the application is evaluated or checked when a user logs in to create a new project. This authentication process likely involves verifying the user's credentials and permissions to access the application and its functionalities. Once the user is authenticated and authorized, they can initiate the process of creating a new project within the application. The authentication phase during login ensures that only authorized users can access the application and perform actions like creating new projects, maintaining security, and controlling access to the application's features and data.

[0029] In step (203), multiple test case files are generated by the profiler with the collaborative assistance of the test case engine. In step (204), the customized and tailored test automation scripts are generated for one or more programming languages using the AF. The method (200) further incorporates automating resolution of the issues encountered during the testing process using the Al component in step (205).

[0030] In an embodiment, the method (200) enhances the application testing procedure by engaging in profiling activities and generating test scenarios employing permutations and combinations. The method (200) encompasses the inclusion of the scraper, which constitutes a specialized tool endowed with the capacity to extract attributes from the UserInterface (UI) elements present within applications. These attributes are vital for facilitating automation and ensuring that the subsequent testing process is effective. Once the attributes are successfully scraped, the method proceeds to access the application or desktop application. The user chooses between web automation or desktop automation and create a new project. The project serves as a central workspace for constructing and organizing the test scenarios and automation processes specific to the application under test. The method employs the profiler, a powerful tool responsible for constructing a centralized offline model of the application under test. This offline model is crucial as it accurately represents the key components and functionalities of the application. To achieve this, the profiler takes the previously generated Comma-Separated Values (CSV) files, containing the extracted attributes of UI elements from the applications, as input. By processing this information, the profiler generates a detailed offline model that serves as a reference for the subsequent steps in the testing process. The subsequent step involves generating customized and tailored test automation scripts for different programming languages. This is made possible through the Automation Framework (AF), a specialized framework designed for test automation purposes. The AF takes the test case files resulting from the collaborative efforts of the profiler and a Test Case Engine (TCE) as the input. This combination ensures that testers can execute comprehensive and reliable test automation, tailored to their preferred programming languages. The method further addresses the inevitable challenges encountered during the testing process with the inclusion of the Artificial Intelligence (Al) . This Al component automatically detects any changes in the application under test that might lead to test script failures. Upon detecting such changes, the Al component initiates an auto healing process, adjusting the test scripts automatically to accommodate the modifications in the application. This auto healing feature significantly reduces the manual effort required to maintain and update test scripts, resulting in a more efficient testing process.

[0031] In an embodiment, the method (200) provides generation of the test scenario through permutation and combination. The profiler plays a critical role in this aspect, creating test scenarios that involve various combinations of input values and conditions. These scenarios are structured and presented using combinatorial datasets, with the help ofa user-friendly drag and drop interface offered by the profiler. This feature simplifies the process of creating test scenarios and enables testers to comprehensively cover a wide range of test cases. In an embodiment, the users can mimic and record user actions, API calls, and database queries on the offline model by follow me feature. This feature supports the creation of comprehensive test scenarios using Gherkin language, covering various aspects of the application's functionality.

[0033] FIG 3 illustrates a flow diagram of the process of generating test scenarios using offline modelling and permutations, in accordance with one embodiment of the present invention. The flow diagram outlines the steps involved in creating and testing a software application using Artificial Intelligence (Al). The process (300) commences with the start node. The scraper initiates the process by scraping attributes of one or more user interface (UI) elements within applications to gather information about their features and functionality, Further, the profiler constructs a centralized offline model by profiling the application under test and measuring its performance, memory usage, and processing unit usage. The gathered information is then utilized by the TCE to generate one or more test case files. These test cases are designed to exert stress on the application, facilitating the detection of potential defects. Further, the AF, generates customized and tailored test automation scripts for one or more programming languages. These scripts enable the automated execution of the test cases, streamlining the testing process. Further, the Al component automates the resolution of issues encountered during the testing process. Furthermore, the process (300) ends with the end node.

[0034] The present invention discloses the method (200) for generating test scenarios using offline modeling and permutations that combines scraping, profiling, and Al technologies to profile applications, generate comprehensive test scenarios, and automate the testing process. Through a centralized offline model, customizable test automation scripts, and automated issue resolution, this method (200) greatly enhances the accuracy, reliability, and effectiveness of the testing process. By leveraging Al-driven techniques, this method (200) significantly improves the efficiency and effectiveness of software testing. As a result, it leads to enhanced software quality and a more streamlined testing process. Theincorporation of Al technologies ensures a proactive and dynamic approach to software testing, addressing potential issues early on and optimizing the overall testing workflow and further contributes to delivering high-quality software products and expediting the software development lifecycle.Reference numbers:

Claims

ClaimsWe claim:

1. A system for generating one or more test scenarios using an offline modeling and permutations, the system (100) comprises: a. a Quality Assurance (QA) application (101) necessitating authentication of one or more users to create a new project, facilitating the execution of offline modeling and profiling of an application under test comprising: i. a scrapper (102) for scraping one or more attributes of one or more User Interface (UI) elements within the application under test for facilitating automation; ii. a profiler (103) for constructing a centralized offline model of the application under test; iii. a Test Case Engine (TCE) (104) for generating one or more test case files with the collaborative assistance of the profiler (103); iv. an Automation Framework (AF) (105) for generating a plurality of customized and tailored test automation scripts for one or more programming languages; and v. an Artificial Intelligence (Al) (106) for automating the resolution of one or more issues encountered during the testing of the application.

2. The system (100) as claimed in claim 1, wherein the system (100) presents the centralized offline model that provides emulation of the application, allowing one or more remote users to work on the application under test without having to be connected to the actual application.

3. A method for generating one or more test scenarios using an offline modeling and permutations, the method (200) comprising the steps of: a. scraping plurality of attributes of one or more user interface (UI) elements within an application under test for facilitating automation using a scraper (201); b. authenticating into the Quality Assurance (QA) application by selecting a web automation or a desktop automation dropdown option for creating a new project enabling the subsequent execution of offline modeling and profiling of the application under test (202); c. constructing a centralized offline model of the application under test using a profiler, taking one or more Comma-Separated Values (CSV) files generated by the scraper as an input, wherein the profiler generates one or more test case files with the help of a Test Case Engine (TCE) (203); d. generating one or more customized and tailored test automation scripts for one or more programming languages using an Automation Framework (AF), wherein the AF takes the test case files generated through the collaborative efforts of the profiler and the TCE as the input (204); and e. automating the resolution of one or more issues encountered during the testing process using an Artificial Intelligence (Al) (205).

4. The method (200) as claimed in claim 3, wherein the CSV file generated by the scraper contains the extracted attributes of the user interface (UI) elements from the application under test and is uploaded to the newly created project within the Quality Assurance (QA) application.

5. The method (200) as claimed in claim 3, wherein the profiler processes the information from the CSV file and constructs the centralized offline model foraccurately representing the components and functionalities of the application under test.

6. The method (200) as claimed in claim 3, wherein the automation framework converts the test scenario into the script by utilizing the test case files generated by the profiler and the Test Case Engine (TCE), thereby enabling testers to execute comprehensive and reliable test automation in the programming language.

7. The method (200) as claimed in claim 3, wherein the test case files comprise a collection of test scenarios, each representing one or more combinations of input values and conditions.

8. The method (200) as claimed in claim 3, wherein the Al component automatically detects the changes in the application under test leading to test script failures and initiates an auto healing process for automatically adjusting the test scripts to accommodate the modifications in the application under test.

9. The method (200) as claimed in claim 3, wherein the profiler generates the test cases through a permutation and combination and creates combinatorial datasets for each scenario with the support of a drag and drop interface.

Images