KR102536392B1 - Method, apparatus and computer program for providing guide to create user customized test case for software quality assurance - Google Patents

Abstract

A method for providing a user-customized test case creation guide for software quality assurance, a device and a computer program are provided. A method for providing a user-customized test case creation guide for software quality assurance according to various embodiments of the present invention is a method performed by a computing device, wherein a test case (Test Case) for software quality assurance (Quality Assurance, QA) is Case, TC) obtaining a request for generating a test case and providing a user interface (UI) for creating a test case to the user in response to the acquired test case creation request, wherein the user interface The providing step includes providing guide information for test case generation to the user.

Description

User-customized test case creation guide provision method, device and computer program for software quality assurance

Various embodiments of the present invention relate to a method, apparatus, and computer program for providing a user-customized test case creation guide for software quality assurance.

Since application programs for smart devices (for example, smart phones, tablet PCs, or notebooks, etc.) first appeared, competition has been intensifying, and the success factors of application programs are not only ideas, but also an era in which functions must be perfect and easy to use. It became.

In other words, in the case of the current application program, it is difficult to succeed with only good ideas, and additionally, it must be well promoted, and it can be successful only when it has perfect functions and is easy to use.

Therefore, now or in the future, it has become a situation where developed application programs must be thoroughly verified before being released to the market. To this end, the software quality assurance (QA) process plays a very important role.

In the conventional software quality assurance method, a number of users directly perform QA work on the software by using the platform according to various scenarios, that is, by performing various types of tests on the software as a target.

However, along with the growth of the IT field, the types and number of functions to be included in the platform increased significantly, shortening the operating period of the existing platform and the time required for the release of a new platform. There was a problem that the required manpower, time and cost were greatly increased.

The problem to be solved by the present invention is to provide an environment in which the user can create a test case, but provide an environment in which the user can more easily create a test case by providing guide information for creating a test case to the user. It is to provide a user-customized test case generation guide providing method, device, and computer program for software quality assurance.

Another problem to be solved by the present invention is to automatically generate a test case for testing and provide it to the user according to obtaining a test request for software quality assurance from the user, so that the user can more easily test for software quality assurance. It is to provide a user-customized test case generation guide providing method, device, and computer program for software quality assurance that can provide an environment in which it can be performed properly.

Another problem to be solved by the present invention is to distribute and allocate test tasks for software quality assurance to a plurality of users, but distribute and allocate test tasks to users suitable for performing tests according to the attributes of the test tasks, An object of the present invention is to provide a user-customized test case creation guide providing method, device, and computer program for software quality assurance that can provide an environment capable of more effectively handling multiple test tasks for software.

The problems to be solved by the present invention are not limited to the problems mentioned above, and other problems not mentioned will be clearly understood by those skilled in the art from the description below.

A method for providing a user-customized test case creation guide for software quality assurance according to an embodiment of the present invention for solving the above problems is a method performed by a computing device, in which software quality assurance (Quality Assurance, QA Obtaining a request for generating a test case (TC) for the ) and providing a user interface (UI) for creating a test case to the user in response to the obtained request for generating a test case. The providing of the user interface may include providing guide information for generating a test case to the user.

In various embodiments, the providing of the guide information may include, when the user wants to generate a test case for testing at least one function among a plurality of functions included in the software, a test case for the at least one function. As the step of selecting the one or more recommended tests and guide information, guide information including information on the one or more selected recommended tests and information on how to generate a test case corresponding to the one or more selected recommended tests is provided, or , providing sample test cases corresponding to the selected one or more recommended tests.

In various embodiments, the step of selecting one or more recommended tests may include determining test performance ability of the user based on a test performance history of the user, and test difficulty level for the user based on the determined test performance capability. and selecting a recommended test for the at least one function based on the determined test difficulty.

In various embodiments, the selecting of one or more recommended tests may include determining a test range for the user based on attributes of a terminal of the user performing the software test, and based on the determined test range. and selecting a recommended test for the at least one function.

In various embodiments, a plurality of pre-generated test cases are collected to test a plurality of software and a plurality of functions included in each of the plurality of software, and the collected plurality of test cases are classified and stored to test the test cases. The step of constructing a database is further included, and the step of providing the guide information corresponds to a test object, wherein the test object is at least one function among a plurality of functions included in the software, from the built test case database. extracting a plurality of test cases, extracting patterns of the extracted plurality of test cases through big data analysis of the extracted plurality of test cases, and based on the extracted patterns, A step of providing guide information for generating a corresponding test case may be included.

In various embodiments, generating a test case generation model by learning a plurality of pre-generated test cases as learning data to test a plurality of software and a plurality of functions included in each of the plurality of software. In the step of providing the guide, one or more information about the test object (the test object being at least one function among a plurality of functions included in the software) is input to the generated test case generation model. The method may include extracting test cases and providing the extracted one or more test cases to the user as sample test cases for the test target.

In various embodiments, the providing of the guide information may include generating a plurality of first test cases corresponding to a test target, wherein the test target is at least one function among a plurality of functions included in the software, from the user. In this case, a pre-constructed test case database - the pre-constructed test case database is a classification and storage of a plurality of pre-generated test cases to test a plurality of software and a plurality of functions included in each of the plurality of software - extracting a plurality of second test cases corresponding to the test target from, extracting a pattern of the extracted plurality of second test cases through big data analysis on the extracted plurality of second test cases; Performing verification on the generated plurality of first test cases based on the extracted pattern, and providing guide information to the user based on a result of performing verification on the generated plurality of first tests. can include

In various embodiments, the providing of the guide information may include determining that an issue with the software has occurred based on a test performance result derived as the user performs a test for the software according to a pre-generated test case. If it is determined, selecting one or more additional tests for the generated issue and a method of generating test cases corresponding to the selected one or more additional tests and information on the selected one or more additional tests as guide information. It may include providing guide information including information about or providing sample test cases corresponding to the selected one or more additional tests.

In various embodiments, the providing of the guide information may include, when a test case generation request for the same test object is obtained from two or more different users, each of the two or more different users for the same test object is different from each other. The method may include providing guide information for generating test cases corresponding to the different types of tests to each of the two or more different users to perform tests of different types.

A computing device that performs a method for providing a user-customized test case generation guide for software quality assurance according to another embodiment of the present invention for solving the above problems is a processor, a network interface, a memory, and loaded into the memory, A computer program executed by the processor, wherein the computer program includes instructions for obtaining a request for generating a test case (TC) for quality assurance (QA) of software from a user and the In response to the acquired test case generation request, an instruction for providing a user interface (UI) for test case generation to the user is included, and the instruction for providing the user interface may cause the user to create a test case. It may include an instruction providing guide information for

A computer program according to another embodiment of the present invention for solving the above problems is combined with a computing device and receives a request for generating a test case (TC) for quality assurance (QA) of software from a user. In response to the acquiring step and the acquired test case creation request, providing a user interface (UI) for generating a test case to the user, wherein providing the user interface includes: It may be stored in a recording medium readable by a computing device in order to execute a user-customized test case generation guide providing method for software quality assurance, which includes providing guide information for test case generation to a computer.

Other specific details of the invention are included in the detailed description and drawings.

According to various embodiments of the present invention, an environment in which a test case can be created is provided to the user, and guide information for test case creation is provided to the user, thereby providing an environment in which the user can more easily create the test case. There are advantages to being able to do it.

In addition, as a test request for software quality assurance is obtained from the user, test cases for testing are automatically generated and provided to the user, thereby creating an environment in which the user can more easily perform tests for software quality assurance. It has the advantage of being able to provide

In addition, while distributing and allocating test tasks for software quality assurance to multiple users, multiple test tasks for software are distributed and allocated to users suitable for performing tests according to the nature of the test tasks. It has the advantage of being able to provide an environment that can be processed more effectively.

The effects of the present invention are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

1 is a diagram illustrating a system for providing a solution for software quality assurance according to an embodiment of the present invention.
2 is a diagram illustrating a hardware configuration of a computing device according to another embodiment of the present invention.
3 is a flowchart illustrating a method of providing a guide for generating test cases as a solution for software quality assurance, in various embodiments.
4 is a flowchart illustrating a method of providing guide information based on big data analysis, in various embodiments.
5 is a flowchart illustrating a method of providing guide information based on a test case generation model in various embodiments.
6 is a flowchart illustrating a method of automatically generating test cases as a solution for software quality assurance in various embodiments.
7 is a flowchart illustrating a method of automatically generating test cases based on big data analysis, in various embodiments.
8 is a flowchart illustrating a method of automatically generating a test case based on a test case generation model, in various embodiments.
9 is a flow chart illustrating a method for allocating test tasks as a solution for software quality assurance, in various embodiments.
10 is a flowchart illustrating a method of allocating test tasks according to difficulty levels, in various embodiments.
11 is a flowchart illustrating a method of allocating test tasks according to types, in various embodiments.
12 is a flowchart illustrating a method of providing a reward for performing a test to a user, in various embodiments.
13 to 26 exemplarily illustrate a user interface (UI) provided by a computing device in various embodiments.

Advantages and features of the present invention, and methods of achieving them, will become clear with reference to the detailed description of the following embodiments taken in conjunction with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below, but may be implemented in various different forms, only these embodiments are intended to complete the disclosure of the present invention, and are common in the art to which the present invention belongs. It is provided to fully inform the person skilled in the art of the scope of the invention, and the invention is only defined by the scope of the claims.

Terminology used herein is for describing the embodiments and is not intended to limit the present invention. In this specification, singular forms also include plural forms unless specifically stated otherwise in a phrase. As used herein, "comprises" and/or "comprising" does not exclude the presence or addition of one or more other elements other than the recited elements. Like reference numerals throughout the specification refer to like elements, and “and/or” includes each and every combination of one or more of the recited elements. Although "first", "second", etc. are used to describe various components, these components are not limited by these terms, of course. These terms are only used to distinguish one component from another. Accordingly, it goes without saying that the first element mentioned below may also be the second element within the technical spirit of the present invention.

Unless otherwise defined, all terms (including technical and scientific terms) used in this specification may be used with meanings commonly understood by those skilled in the art to which the present invention belongs. In addition, terms defined in commonly used dictionaries are not interpreted ideally or excessively unless explicitly specifically defined.

The term "unit" or "module" used in the specification means a hardware component such as software, FPGA or ASIC, and "unit" or "module" performs certain roles. However, "unit" or "module" is not meant to be limited to software or hardware. A “unit” or “module” may be configured to reside in an addressable storage medium and may be configured to reproduce one or more processors. Thus, as an example, a “unit” or “module” may refer to components such as software components, object-oriented software components, class components, and task components, processes, functions, properties, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays and variables. Functions provided within components and "units" or "modules" may be combined into smaller numbers of components and "units" or "modules" or may be combined into additional components and "units" or "modules". can be further separated.

The spatially relative terms "below", "beneath", "lower", "above", "upper", etc. It can be used to easily describe a component's correlation with other components. Spatially relative terms should be understood as including different orientations of elements in use or operation in addition to the orientations shown in the drawings. For example, if you flip a component that is shown in a drawing, a component described as "below" or "beneath" another component will be placed "above" the other component. can Thus, the exemplary term “below” may include directions of both below and above. Components may also be oriented in other orientations, and thus spatially relative terms may be interpreted according to orientation.

In this specification, a computer means any kind of hardware device including at least one processor, and may be understood as encompassing a software configuration operating in a corresponding hardware device according to an embodiment. For example, a computer may be understood as including a smartphone, a tablet PC, a desktop computer, a laptop computer, and user clients and applications running on each device, but is not limited thereto.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings.

Although each step described in this specification is described as being performed by a computer, the subject of each step is not limited thereto, and at least a part of each step may be performed in different devices according to embodiments.

1 is a diagram illustrating a system for providing a solution for software quality assurance according to an embodiment of the present invention.

Referring to FIG. 1 , a system for providing a solution for software quality assurance according to an embodiment of the present invention may include a computing device 100, a user terminal 200, an external server 300, and a network 400. .

Here, the solution providing system for software quality assurance shown in FIG. 1 is according to an embodiment, and its components are not limited to the embodiment shown in FIG. 1, and may be added, changed, or deleted as necessary. .

In one embodiment, the computing device 100 may provide a solution providing service for software quality assurance.

In various embodiments, the computing device 100 may provide a user-customized test case generation guide for software quality assurance. For example, when a user wants to create a test case for quality assurance of software, the computing device 100 may provide guide information for generating a test case so that the user can more easily create the test case.

In various embodiments, the computing device 100 may automatically generate test cases for software quality assurance. For example, when a user wants to perform a test for quality assurance of software, the computing device 100 may automatically generate a test case for testing and provide it to the user.

In various embodiments, the computing device 100 may assign testing tasks for software quality assurance to users. For example, when a user intends to perform a test for software quality assurance, the computing device 100 may create a plurality of test tasks for software testing and assign test tasks to users suitable for the test.

In various embodiments, the solution providing service for software quality assurance provided by the computing device 100 may be implemented in the form of application software such as a web or application, and as the web or application software is executed, A solution providing service UI (eg, FIGS. 13 to 26) for software quality assurance may be provided.

In one embodiment, the user terminal 200 may be connected to the computing device 100 through the network 400, and the user executes a web or application software provided from the computing device 100 through the user terminal 200. As a result, you can use the solution provision service for software quality assurance.

Here, the user terminal 200 includes an operating system capable of driving a web or application, and a device (eg, navigation, PCS (eg, navigation, PCS Personal Communication System), GSM (Global System for Mobile communications), PDC (Personal Digital Cellular), PHS (Personal Handyphone System), PDA (Personal Digital Assistant), IMT (International Mobile Telecommunication)-2000, CDMA (Code Division Multiple Access) )-2000, W-CDMA (W-Code Division Multiple Access), Wibro (Wireless Broadband Internet) terminal, smartphone (Smartphone), smart pad (Smartpad), tablet PC (Tablet PC) of all kinds, such as handheld ( Handheld) based wireless communication device, etc.), but is not limited thereto.

Also, here, the network 400 may refer to a connection structure capable of exchanging information between nodes such as a plurality of terminals and servers. For example, the network 400 includes a local area network (LAN), a wide area network (WAN), a world wide web (WWW), a wired and wireless data communication network, a telephone network, a wired and wireless television communication network, and the like. can do.

In addition, here, the wireless data communication networks are 3G, 4G, 5G, 3GPP (3rd Generation Partnership Project), 5GPP (5th Generation Partnership Project), LTE (Long Term Evolution), WIMAX (World Interoperability for Microwave Access), Wi-Fi (Wi-Fi) Fi), Internet, LAN (Local Area Network), Wireless LAN (Wireless Local Area Network), WAN (Wide Area Network), PAN (Personal Area Network), RF (Radio Frequency), Bluetooth network, A near-field communication (NFC) network, a satellite broadcasting network, an analog broadcasting network, a digital multimedia broadcasting (DMB) network, etc. may be included, but is not limited thereto.

In one embodiment, the external server 300 may be connected to the computing device 100 through the network 400, and various information and data necessary for the computing device 100 to provide a solution providing service for software quality assurance. (eg, a plurality of software (or a plurality of functions included in the plurality of software), a plurality of test cases for each test, a plurality of user information (eg, a user manpower pool in which a plurality of user information is registered, etc.) are stored and management, or various information and data generated as the computing device 100 provides a solution providing service for software quality assurance (eg, test cases for specific software (or specific functions of specific software), assignment history of test tasks) etc.) can be provided, stored and managed.

For example, the external server 300 may be a storage server provided separately outside the computing device 100, but is not limited thereto. Hereinafter, with reference to FIG. 2, the hardware configuration of the computing device 100 providing a solution providing service for software quality assurance will be described.

2 is a diagram illustrating a hardware configuration of a computing device according to another embodiment of the present invention.

Referring to FIG. 2 , in various embodiments, a computing device 100 includes one or more processors 110, a memory 120 for loading a computer program 151 executed by the processor 110, and a bus ( 130), a communication interface 140, and a storage 150 for storing the computer program 151. Here, in FIG. 2, only components related to the embodiment of the present invention are shown. Therefore, those skilled in the art to which the present invention pertains can know that other general-purpose components may be further included in addition to the components shown in FIG. 2 .

The processor 110 controls the overall operation of each component of the computing device 100 . The processor 110 includes a Central Processing Unit (CPU), a Micro Processor Unit (MPU), a Micro Controller Unit (MCU), a Graphic Processing Unit (GPU), or any type of processor well known in the art of the present invention. It can be.

Also, the processor 110 may perform an operation for at least one application or program for executing a method according to embodiments of the present invention, and the computing device 100 may include one or more processors.

In various embodiments, the processor 110 may temporarily and/or permanently store signals (or data) processed in the processor 110 (RAM: Random Access Memory, not shown) and ROM (ROM: Read -Only Memory, not shown) may be further included. In addition, the processor 110 may be implemented in the form of a system on chip (SoC) including at least one of a graphics processing unit, RAM, and ROM.

Memory 120 stores various data, commands and/or information. Memory 120 may load computer program 151 from storage 150 to execute methods/operations according to various embodiments of the present invention. When the computer program 151 is loaded into the memory 120, the processor 110 may perform the method/operation by executing one or more instructions constituting the computer program 151. The memory 120 may be implemented as a volatile memory such as RAM, but the technical scope of the present disclosure is not limited thereto.

The bus 130 provides a communication function between components of the computing device 100 . The bus 130 may be implemented in various types of buses such as an address bus, a data bus, and a control bus.

The communication interface 140 supports wired and wireless Internet communication of the computing device 100 . Also, the communication interface 140 may support various communication methods other than internet communication. To this end, the communication interface 140 may include a communication module well known in the art. In some embodiments, communication interface 140 may be omitted.

The storage 150 may non-temporarily store the computer program 151 . When performing a user-customized test case generation guide provision process for software quality assurance, a test case automatic generation process for software quality assurance, and a test task assignment process for software quality assurance through the computing device 100, storage ( 150) can store various information necessary to provide a user-customized test case generation guide provision process for software quality assurance, a test case automatic generation process for software quality assurance, and a test assignment process for software quality assurance. .

The storage 150 may be a non-volatile memory such as read only memory (ROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, or the like, a hard disk, a removable disk, or a device well known in the art. It may be configured to include any known type of computer-readable recording medium.

Computer program 151 may include one or more instructions that when loaded into memory 120 cause processor 110 to perform methods/operations in accordance with various embodiments of the invention. That is, the processor 110 may perform the method/operation according to various embodiments of the present disclosure by executing the one or more instructions.

In one embodiment, the computer program 151 obtains a test case generation request for software quality assurance (QA) from the user and provides a user interface for test case generation to the user in response to the obtained test case generation request. One or more instructions for performing a method for providing a user-customized test case creation guide for software quality assurance, which includes providing a user interface with guide information for generating a test case to a user. can include

In addition, the computer program 151 may include acquiring a test request for quality assurance of software from a user, generating a test case for testing the software in response to the obtained test request, and generating the test case to the user. It may include one or more instructions for performing a method of automatically generating test cases for quality assurance of software, including the step of providing.

In addition, the computer program 151 includes generating a test task for quality assurance of software and allocating the created test task to at least one user among a plurality of pre-registered users based on the attributes of the created test task. It may include one or more instructions for performing a test task assignment method for software quality assurance including steps.

Steps of a method or algorithm described in connection with an embodiment of the present invention may be implemented directly in hardware, implemented in a software module executed by hardware, or implemented by a combination thereof. A software module may include random access memory (RAM), read only memory (ROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, hard disk, removable disk, CD-ROM, or It may reside in any form of computer readable recording medium well known in the art to which the present invention pertains.

Components of the present invention may be implemented as a program (or application) to be executed in combination with a computer, which is hardware, and stored in a medium. Components of the present invention may be implemented as software programming or software elements, and similarly, embodiments may include various algorithms implemented as data structures, processes, routines, or combinations of other programming constructs, such as C, C++ , Java (Java), can be implemented in a programming or scripting language such as assembler (assembler). Functional aspects may be implemented in an algorithm running on one or more processors. Hereinafter, with reference to FIGS. 3 to 12 , methods for providing a solution for software quality assurance provided by the computing device 100 will be described in more detail.

First, with reference to FIG. 3 , a method for providing a user-customized test case creation guide for software quality assurance performed by the computing device 100 will be described.

3 is a flowchart illustrating a method of providing a guide for generating test cases as a solution for software quality assurance, in various embodiments.

Referring to FIG. 3 , in various embodiments, as a solution for software quality assurance, the computing device 100 may provide a user-customized test case creation guide so that the user can more easily create test cases. .

In step S110, the computing device 100 may obtain a test case (TC) generation request for software quality assurance (QA) from the user.

In various embodiments, the computing device 100 may be connected to the user terminal 200 through the network 400, and as the user executes a web or application software through the user terminal 200, the user terminal 200 A UI (eg, FIGS. 13 to 26) may be output on the display, and a test case creation request may be obtained from the user through the output UI.

Here, the operation of obtaining a test case generation request from the user may mean an operation of collecting a signal output as the user selects a test case generation button output through the UI, but is not limited thereto, and a test from the user is not limited thereto. Operation of acquiring a case creation request Operation of acquiring a signal output by selecting the test request button of the software output through the UI or web or application software provided by the computing device 100 through the user terminal 200 by the user It may be the action itself that executes.

Here, a test case is for testing the software itself or at least one function among a plurality of functions included in the software, and a test scenario (Test Scenario, TS) (eg, “what” among the software or functions provided through the software) It may refer to data defining "how" to test an object to be tested, based on data defining what to test.

In step S120, the computing device 100 may provide a UI for generating a test case to the user in response to the test case creation request obtained through step S110.

Here, the UI for test case generation provided by the computing device 100 is a UI that provides an environment in which a user can directly create and create a test case, for example, so that a user can directly create and create a test case. A test case writing template may be output, but is not limited thereto.

In various embodiments, the computing device 100 may provide a user-customized test case generation guide so that the user can more easily create a test case.

For example, when a user wants to create a test case for the purpose of testing at least one function among a plurality of functions included in software, the computing device 100 provides one or more one or more functions for the at least one function to be tested by the user. A recommended test can be selected, information about one or more recommended tests, and a method for generating a test case corresponding to the one or more recommended tests (eg, a method for creating a test case for performing one or more recommended tests, etc.) Guide information including information may be provided as guide information.

As another example, when a user wants to create a test case for the purpose of testing at least one function among a plurality of functions included in software, the computing device 100 may set one or more functions for the at least one function to be tested by the user. Recommended tests may be selected, and sample test cases corresponding to one or more recommended tests may be provided as guide information. However, it is not limited thereto.

In various embodiments, when a user wants to create a test case for the purpose of testing at least one function among a plurality of functions included in software, the computing device 100 provides information about at least one function that the user wants to test. One or more recommended tests may be selected, but the recommended test may be selected based on the user's ability to perform tests. Here, a detailed method of determining and evaluating the user's ability to perform the test will be described later with reference to FIG. 12 .

For example, the computing device 100 may determine a test difficulty suitable for the user based on the user's ability to perform a test, and select a recommended test according to the determined test difficulty.

For example, when the user's ability to perform the test is lower than the first level or lower than the first level, the computing device 100 may determine the difficulty level of the test for the user as "low level", and according to the level of difficulty of the test for the user A test set to a low level of difficulty in advance may be selected as a recommended test.

In addition, the computing device 100 may determine the test difficulty for the user as “middle level” when the user's test performance ability is equal to or higher than the first level and lower than the second level, or higher than the first level and lower than the second level, , a test set to medium difficulty in advance can be selected as a recommended test according to the test difficulty for the user.

In addition, when the user's ability to perform the test is the second level or higher (third level) or higher than the second level, the computing device 100 may determine the difficulty level of the test for the user as "high level", and the user Depending on the difficulty level of the test, a test set to a high level of difficulty in advance may be selected as a recommended test.

In various embodiments, the computing device 100 may provide guide information suitable for the user's test performance ability based on the user's test performance ability.

For example, based on the user's test performance ability, when the user's test performance ability is lower than the first grade or lower than the first level, the computing device 100 provides information about the recommended test and a test corresponding to the recommended test as guide information. Guide information including information on how to create a case and sample test cases corresponding to recommended tests may be provided.

In addition, when the user's test performance ability is equal to or greater than the first level and less than the second level, or greater than or equal to the first level and less than the second level, the computing device 100 provides information on the recommended test and a test case corresponding to the recommended test as guide information. Only guide information including information on the generation method may be provided, or only sample test cases corresponding to recommended tests may be provided.

In addition, when the user's test performance ability is the second level or higher (third level) or higher than the second level, the computing device 100 may provide only recommended test information as guide information.

In various embodiments, the computing device 100 automatically completes at least a portion of the test content corresponding to the one or more keywords through an auto-completion function when receiving input of one or more keywords for writing a test case from a user through a UI, The degree of automatic completion of the test content may be determined based on the user's ability to perform the test. For example, the computing device 100 may automatically complete a phrase, clause, or sentence including one or more keywords when the user's test performance is lower than the first level or lower than the first level. In addition, the computing device 100 determines that the user's test performance ability is equal to or higher than the first level and lower than the second level, or higher than the first level and lower than the second level, a word including one or more keywords or another word having the same meaning as the corresponding word. can be provided as suggested words. However, it is not limited thereto.

In various embodiments, the computing device 100 may provide guide information for generating a test case suitable for execution in the user terminal 200 based on the property of the user terminal 200 that performs a software test. there is. For example, the computing device 100 tests the range of the user (ie, the user terminal 200) based on the properties of the user terminal 200 (eg, the type (type of operating system) and performance of the user terminal 200). ) may be determined, a recommended test may be selected based on the determined test range, and guide information for generating a test case corresponding to the selected recommended test may be provided.

In various embodiments, the computing device 100 may provide guide information based on a test performance result obtained when a user performs a test on software (or a specific function of software) according to a pre-generated test case. there is. For example, when the computing device 100 determines that an issue with software has occurred based on a test performance result obtained as a user performs a software test according to a pre-generated test case (eg, a test execution result). is "failed"), one or more additional tests corresponding to the generated issue may be selected, and as guide information, information about the one or more additional tests How to generate test cases corresponding to the one or more additional tests You can provide guidance information, including information, or sample test cases corresponding to one or more additional tests.

In various embodiments, when the user wants to create a test case for the first software, the computing device 100 provides guide information to the user based on an issue occurrence history of the second software having the same type as the first software. can do.

More specifically, first, when a user wants to create a test case for a first software providing a role-playing game, the computing device 100 includes a plurality of second software (of the same kind as the first software) among a plurality of software. Example: A plurality of second software providing a role-playing game) is selected, and an issue arises for each of a plurality of functions included in the plurality of second software based on the results of a plurality of tests performed on the selected plurality of second software. number of times can be counted.

Thereafter, the computing device 100 selects, as a feature of interest, a function for which the number of occurrences of an issue is equal to or greater than the reference number among a plurality of functions included in a plurality of second software, and selects one or more recommended tests for testing the function selected as the feature of interest. As guide information, guide information including information on one or more recommended tests and information on how to generate test cases corresponding to one or more recommended tests is provided, or sample tests corresponding to one or more recommended tests are provided. case can be provided.

At this time, the computing device 100 selects recommended tests for testing the function selected as the function of interest, and determines the number of recommended tests to be selected based on the number of occurrences of issues. For example, the computing device 100 may select one recommendation test for the first function when the number of occurrences of issues of the first function selected as the function of interest is less than the first number of times, and the first function selected as the function of interest If the number of occurrences of issues is equal to or greater than the first number and less than the second number, two recommended tests for the first function may be selected. More than three recommended tests can be selected. However, it is not limited thereto.

In various embodiments, the computing device 100, when a test case generation request for the same test object (software or at least one function among a plurality of functions included in the software) is obtained from two or more different users, the same test object Guide information for generating test cases corresponding to different types of tests may be provided to each of the two or more different users so that the two or more different users each perform different types of tests.

In various embodiments, the computing device 100 may set a test degree (test importance) for a test target in advance, and a plurality of users perform different types of tests for a test target having a low test importance. Different guide information may be provided to users, and the same guide information may be provided to a plurality of users so that the plurality of users may perform the same type of test on a test subject having a high test importance.

In various embodiments, the computing device 100 may provide guide information for test case generation to the user based on big data analysis or guide information for test case generation to the user based on an artificial intelligence model. . Hereinafter, it will be described in more detail with reference to FIGS. 4 and 5 .

4 is a flowchart illustrating a method of providing guide information based on big data analysis, in various embodiments.

Referring to FIG. 4 , in step S210 , the computing device 100 may build a test case database.

In various embodiments, the computing device 100 may collect a plurality of test cases generated to test a plurality of software and a plurality of functions included in each of the plurality of software, and classify the plurality of test cases (eg, , Classification according to the type of test subject (type of software or function included in software), difficulty, type, etc.) and storage, a test case database for big data analysis can be constructed.

Here, the plurality of test cases collected by the computing device 100 may be test cases directly generated by a user through a platform provided by the computing device 100, but are not limited thereto, and are not limited thereto. A plurality of collected test cases is a collection of a plurality of test cases generated through an external program and processed according to a predefined template, or a plurality of test cases collected by the computing device 100 is the computing device 100 ) may include test cases automatically generated by (eg, test cases generated through step S420 of FIG. 6 to be described later).

In addition, here, the big data-based data collection and storage method includes various technologies (e.g., big data collection technology (log collection, crawling, sensing, RSS, Open API) and big data storage technology (NoSQL, File System, Cloud, network)), and these various known technologies can be selectively applied according to circumstances, and in this specification, a method for collecting and storing data based on big data performed by the computing device 100 is specifically disclosed. I never do that.

In step S220, the computing device 100 corresponds to a test target (eg, a target to be tested by a user, software or at least one function among a plurality of functions included in the software) from the test case database built through step S210. Multiple test cases can be extracted. For example, when a user wants to test a specific function of software, the computing device 100 may extract a plurality of test cases corresponding to the specific function from a test case database.

In various embodiments, the computing device 100 may filter a plurality of test cases extracted from a test case database based on test preferences of the user. For example, the computing device 100 may obtain preference information including information about the user's preferred test type and non-preferred test type from the user, extract a plurality of test cases corresponding to the test target from the database, and extract the extracted test cases. Among the plurality of test cases, only test cases corresponding to a test type preferred by the user may be selected, or test cases corresponding to a test type not preferred by the user may be filtered out of the plurality of extracted test cases.

In various embodiments, the computing device 100 may filter a plurality of test cases extracted from a test case database based on a user's test execution history. For example, the computing device 100 performs tests by type based on a user's test performance history (eg, a plurality of test performance results obtained by performing a test on a test target according to a plurality of pre-generated test cases). The number of times can be counted, and a plurality of test cases corresponding to the test target are extracted from the database, and among the extracted plurality of test cases, only the test cases corresponding to the test type having a counted number of executions equal to or greater than the reference number are selected or the plurality of extracted test cases are selected. Test cases corresponding to test types in which the counted number of executions is less than the reference number among the test cases in can be filtered.

In step S230, the computing device 100 analyzes the plurality of test cases extracted through step S220 (or the plurality of test cases filtered based on the user's preference and/or the user's test execution history) to analyze the big data to be the test target. Guide information for generating test cases corresponding to can be provided.

More specifically, first, the computing device 100 may extract patterns of a plurality of test cases by big data analysis on a plurality of test cases extracted from a test case database. For example, the computing device 100 analyzes the big data of a plurality of test cases corresponding to a specific function to determine what type of test was performed for a specific function, what kind of test was performed in what way, and/or what type of test was performed. Patterns, such as how many tests have been performed, that is, test case generation patterns for specific functions can be extracted as feature data for a plurality of test cases.

Here, as for the method of extracting specific data from pre-stored big data, various technologies are already known (e.g., big data processing technology (a method of extracting result values from a large database through a query, a method of extracting result values through real-time processing) )), and these various known technologies can be selectively applied according to circumstances, and the present specification does not specifically disclose the big data processing method performed by the computing device 100.

Thereafter, the computing device 100 may provide guide information for generating a test case corresponding to a test target based on feature data (test case generation pattern) extracted through big data analysis.

For example, when the computing device 100 analyzes big data on a plurality of test cases corresponding to a specific function and determines that the first test and the second test have been performed for the specific function, the first test and the second test are performed. may be selected as a recommended test, guide information including information on the first test and the second test selected as the recommended test, and information on how to generate a test case corresponding to the first test and the second test; Sample test cases corresponding to the test and the second test may be provided as guide information.

Here, the sample test case corresponding to the first test and the second test may be at least one test case among a plurality of test cases extracted through step S220, but is not limited thereto.

5 is a flowchart illustrating a method of providing guide information based on a test case generation model in various embodiments.

Referring to FIG. 5 , in step S310 , the computing device 100 may generate a test case generation model.

In various embodiments, the computing device 100 generates a test case generation model by learning a plurality of test cases generated to test a plurality of software and a plurality of functions included in each of the plurality of software as training data. can do.

For example, the computing device 100 may generate learning data by labeling information about a test subject and information about a test (test type, type, difficulty level, etc.) for each of a plurality of test cases, A test that extracts a recommended test for a specific test target using information on a specific test target as input data or extracts a test case corresponding to the recommended test by learning a test case generation model according to the supervised learning method You can create a case generation model.

A test case generation model (e.g., a neural network) consists of one or more network functions, which may consist of a set of interconnected computational units, commonly referred to as ‘nodes’. These 'nodes' may also be referred to as 'neurons'. One or more network functions include at least one or more nodes. Nodes (or neurons) that make up one or more network functions can be interconnected by one or more 'links'.

In the test case generation model, one or more nodes connected through a link may form a relationship of a relative input node and an output node. The concept of an input node and an output node is relative, and any node in an output node relationship with one node may have an input node relationship with another node, and vice versa. As described above, the input node to output node relationship can be created around the link. More than one output node can be connected to one input node through a link, and vice versa.

In a relationship between an input node and an output node connected through one link, the value of the output node may be determined based on data input to the input node. Here, a node interconnecting an input node and an output node may have a weight. Weights may be variable, and may be varied by a user or an algorithm in order to perform a desired function of a test case generation model. For example, when one or more input nodes are interconnected by respective links to one output node, the output node is set to a link corresponding to values input to input nodes connected to the output node and respective input nodes. An output node value may be determined based on the weight.

As described above, in the test case generation model, one or more nodes are interconnected through one or more links to form an input node and output node relationship in the test case generation model. Characteristics of the test case generation model may be determined according to the number of nodes and links in the test case generation model, the relationship between the nodes and links, and the value of the weight assigned to each link. For example, if there are two test case generation models with the same number of nodes and links and different weight values between the links, the two test case generation models may be recognized as different from each other.

Some of the nodes constituting the test case generation model may constitute one layer based on distances from the first input node. For example, a set of nodes having a distance of n from the first input node may constitute n layers. The distance from the first input node may be defined by the minimum number of links that must be passed through to reach the corresponding node from the first input node. However, the definition of such a layer is arbitrary for explanation, and the order of a layer in the test case generation model may be defined in a different way from the above. For example, a layer of nodes may be defined by a distance from a final output node.

The first input node may refer to one or more nodes to which data is directly input without going through a link in relation to other nodes among nodes in the test case generation model. Alternatively, in the relationship between nodes based on a link in the test case generation model network, it may mean nodes that do not have other input nodes connected by a link. Similarly, the final output node may mean one or more nodes that do not have an output node in relation to other nodes among nodes in the test case generation model. In addition, the hidden node may refer to nodes constituting the test case generation model other than the first input node and the last output node. In the test case generation model according to an embodiment of the present invention, the number of nodes of the input layer may be greater than the nodes of the hidden layer close to the output layer, and the number of nodes decreases as the number of nodes increases from the input layer to the hidden layer. can be a model

A test case generation model may include one or more hidden layers. A hidden node of a hidden layer may use outputs of previous layers and outputs of neighboring hidden nodes as inputs. The number of hidden nodes for each hidden layer may be the same or different. The number of nodes of the input layer may be determined based on the number of data fields of the input data and may be the same as or different from the number of hidden nodes. Input data input to the input layer may be operated by a hidden node of the hidden layer and may be output by a fully connected layer (FCL) that is an output layer.

In various embodiments, the test case generation model may be a deep learning model.

A deep learning model (e.g., a deep neural network (DNN)) may refer to a test case generation model that includes a plurality of hidden layers in addition to an input layer and an output layer. With a deep neural network, data can identify the latent structures of a photograph, text, video, sound, or music (e.g., what objects are in a photograph; what the content and emotion of a text are; content and emotions, etc.) can be grasped.

Deep neural networks include convolutional neural networks (CNN), recurrent neural networks (RNNs), auto encoders, generative adversarial networks (GANs), and restricted Boltzmann machines (RBMs). boltzmann machine), deep belief network (DBN), Q network, U network, Siamese network, etc., but is not limited thereto.

In various embodiments, the network function may include an autoencoder. Here, the auto encoder may be a type of artificial neural network for outputting output data similar to input data.

An auto-encoder may include at least one hidden layer, and an odd number of hidden layers may be disposed between input and output layers. The number of nodes of each layer may be reduced from the number of nodes of the input layer to an intermediate layer called the bottleneck layer (encoding), and then expanded symmetrically with the reduction from the bottleneck layer to the output layer (symmetrical to the input layer). Nodes of the dimension reduction layer and the dimension restoration layer may or may not be symmetrical. Also, autoencoders can perform nonlinear dimensionality reduction. The number of input layers and output layers may correspond to the number of remaining sensors after preprocessing of input data. In the auto-encoder structure, the number of hidden layer nodes included in the encoder may decrease as the distance from the input layer increases. If the number of nodes in the bottleneck layer (the layer with the fewest nodes located between the encoder and decoder) is too small, a sufficient amount of information may not be conveyed, so more than a certain number (e.g., more than half of the input layer, etc.) ) may be maintained.

In step S320, the computing device 100 may output result data through the test case generation model generated through step S310. For example, as the computing device 100 inputs information about a test object (eg, an object to be tested by a user, software or at least one function among a plurality of functions included in the software) to a test case generation model, the computing device 100 inputs result data. As , it is possible to output a recommended test for the test target or output a test case for testing the test target.

In step S330, the computing device 100 may provide guide information for generating a test case corresponding to the test target based on the result data output through step S320.

For example, when the recommended test for the test target is output as information on the test target is input to the test case generation model, the computing device 100 uses information on the recommended test and a test corresponding to the recommended test as guide information. Guide information including information on how to create a case may be provided, or a sample test case corresponding to a recommended test may be provided.

As another example, when one or more test cases for the test object are output as information on the test object is input into the test case generation model, the computing device 100 converts the one or more test cases to the user as a sample test case for the test object. can be provided to

As another example, when a plurality of test cases for the test target are output as information on the test target is input to the test case generation model, the computing device 100 analyzes the plurality of output test cases to extract a pattern. The recommended test may be selected based on the extracted pattern, and guide information including information on the recommended test and information on how to generate a test case corresponding to the recommended test may be provided as guide information, or a recommendation may be made. A sample test case corresponding to the test can be provided.

Again, referring to FIG. 3 , in step S130 , the computing device 100 may generate a test case based on a user input obtained through a user interface provided through step S120 . For example, the user may refer to guide information provided from the computing device 100, create a test case through the UI, and then select completion of test case creation, and the computing device 100 selects completion of test case creation from the user. As a result, test cases can be created based on the contents written by the user.

In various embodiments, the computing device 100 may perform verification on a test case created by a user and provide guide information based on the verification result.

More specifically, when a first test case for testing a test object is generated by a user, the computing device 100 may extract a plurality of second test cases corresponding to the test object from a test case database, and A similarity between the test case and the plurality of second test cases may be calculated, and the first test case may be verified based on the similarity between the first test case and the plurality of second test cases.

For example, the computing device 100 may determine that the first test case is accurately generated when the similarity between the first test case and the plurality of second test cases is greater than or equal to the reference similarity, and may determine that the first test case and the plurality of second test cases are accurately generated. If the degree of similarity is less than the similarity criterion between test cases, it may be determined that the first test case is incorrectly generated.

In various embodiments, the computing device 100 may calculate a plurality of unit similarities for each of the plurality of items included in the first test case and the plurality of items included in each of the plurality of second test cases, An average value of unit similarities may be calculated as similarities between the first test case and a plurality of second test cases.

In this case, when the computing device 100 determines that the first test case is incorrectly generated according to the degree of similarity less than the similarity criterion between the first test case and the plurality of second test cases, the computing device 100 provides the user with a correction for the first test case. You can provide guide information to guide your request.

For example, first, if the similarity between one test case and a plurality of second test cases is less than the criterion similarity, the computing device 100 determines a plurality of unit similarities and a reference unit similarity corresponding to each of a plurality of items included in the first test case. After the comparison, at least one item having a degree of similarity less than a criterion unit may be selected as an item requiring modification.

Thereafter, the computing device 100 provides guide information including information on the item requiring modification, information on how to create the item requiring modification, or samples corresponding to the item requiring modification (eg, a plurality of second test cases). Among a plurality of items included in , contents of items corresponding to the modified item) may be provided.

In various embodiments, the computing device 100 may extract a plurality of second test cases corresponding to the test target from a test case database when a plurality of first test cases for testing the test target are generated by the user, , Verification of the plurality of first test cases may be performed based on patterns extracted through big data analysis of the plurality of second test cases.

For example, the computing device 100 may perform verification of the plurality of first test cases by comparing test types according to the plurality of first test cases generated by the user with test types extracted through big data analysis. there is. For example, the computing device 100 shows a pattern of performing a first test, a second test, and a third test on a test subject based on a pattern extracted through big data analysis, but a plurality of first tests generated by a user. When the test cases include only test cases corresponding to the first test and the second test, guide information guiding to additionally generate a test case corresponding to the third test may be provided.

As another example, the computing device 100 compares the test case ratio for each test according to the plurality of first test cases generated by the user and the test case ratio for each test extracted through big data analysis to determine the results for the plurality of first test cases. verification can be performed. For example, the computing device 100 shows a pattern of performing a first test and a second test on a test subject at a ratio of 1:2 based on a pattern extracted through big data analysis, but a plurality of third tests generated by a user. If the ratio of the first test and the second test according to 1 test case is 2:1, reduce the number of test cases corresponding to the first test so that the ratio of the first test and the second test is 1:2; Guide information guiding to increase the number of test cases corresponding to the second test may be provided.

Next, with reference to FIG. 6 , a method for providing a user-customized test case creation guide for software quality assurance performed by the computing device 100 will be described.

6 is a flowchart illustrating a method of automatically generating test cases as a solution for software quality assurance in various embodiments.

Referring to FIG. 6 , in various embodiments, the computing device 100 is a solution for software quality assurance, allowing a user to more easily test software (or at least one function among a plurality of functions included in the software). Test cases can be automatically generated and provided to users for execution.

In step S410, the computing device 100 may acquire a test request for software quality assurance.

In various embodiments, the computing device 100 may be connected to the user terminal 200 through the network 400, and as the user executes a web or application software through the user terminal 200, the user terminal 200 A UI (eg, FIGS. 13 to 26 ) may be output on a display, and a test request for software may be obtained from a user through the output UI.

Here, the operation of obtaining a test request from the user may mean an operation of collecting a signal output as the user selects a test request button of software output through the UI, but is not limited thereto, and a test request from the user The operation of obtaining is an operation of obtaining a signal output as the test case generation button outputted through the UI is selected, or an operation in which the user executes a web or application software provided by the computing device 100 through the user terminal 200. It could be the action itself.

In step S420, the computing device 100 may automatically generate a test case for testing the test target in response to the test request acquired through step S410. Here, the method of automatically generating a test case performed by the computing device 100 determines the type and method of a test to be performed in response to a test target, generates content (text) related to the determined type and method of the test, , The test case may be automatically generated by corresponding the contents of the type and method of the test to each of a plurality of items included in a predefined test case template, but is not limited thereto.

In various embodiments, when a user wants to test at least one function among a plurality of functions included in software, the computing device 100 may select one or more recommended tests for the at least one function, and may select one or more recommended tests. One or more test cases corresponding to the tests (test cases for performing one or more recommended tests) can be created.

In various embodiments, when a user wants to test at least one function among a plurality of functions included in software, the computing device 100 selects one or more recommended tests for the at least one function to be tested by the user. However, based on the user's ability to perform the test, a test difficulty suitable for the user may be determined, and a recommended test may be selected according to the determined test difficulty.

For example, when the user's ability to perform the test is lower than the first level or lower than the first level, the computing device 100 may determine the difficulty level of the test for the user as "low level", and in advance according to the determined level of difficulty of the test. A test set to a low level of difficulty may be selected as a recommended test.

In addition, the computing device 100 may determine the test difficulty for the user as “middle level” when the user's test performance ability is equal to or higher than the first level and lower than the second level, or higher than the first level and lower than the second level, , according to the determined test difficulty, a test set to medium difficulty in advance may be selected as a recommended test.

In addition, when the user's ability to perform the test is the second level or higher (third level) or higher than the second level, the computing device 100 may determine the difficulty level of the test for the user as “high level”, and the determined test Depending on the difficulty level, a test set to a high level of difficulty in advance may be selected as a recommended test.

In various embodiments, the computing device 100 may generate a test case suitable for execution in the user terminal 200 based on the property of the user terminal 200 that performs a test on software. For example, the computing device 100 tests the range of the user (ie, the user terminal 200) based on the properties of the user terminal 200 (eg, the type (type of operating system) and performance of the user terminal 200). ) may be determined, a recommended test may be selected based on the determined test range, and a test case corresponding to the selected recommended test may be created.

In various embodiments, the computing device 100 may automatically generate a test case based on a test execution result derived as a user performs a test on software (or a specific function of the software) according to a pre-generated test case. can For example, when the computing device 100 determines that an issue with software has occurred based on a test performance result obtained as a user performs a software test according to a pre-generated test case (eg, a test execution result). is "failed"), one or more additional tests corresponding to the generated issue may be selected, and one or more additional test cases corresponding to the one or more additional tests may be created.

In various embodiments, when a user wants to create a test case for the first software, the computing device 100 may create the test case based on an issue occurrence history of the second software having the same type as the first software. there is.

More specifically, first, when a user wants to create a test case for a first software providing a role-playing game, the computing device 100 includes a plurality of second software (of the same kind as the first software) among a plurality of software. Example: A plurality of second software providing a role-playing game) is selected, and an issue arises for each of a plurality of functions included in the plurality of second software based on the results of a plurality of tests performed on the selected plurality of second software. number of times can be counted.

Thereafter, the computing device 100 selects, as a feature of interest, a function for which the number of occurrences of an issue is equal to or greater than the reference number among a plurality of functions included in a plurality of second software, and selects one or more recommended tests for testing the function selected as the feature of interest. and create test cases corresponding to the recommended tests.

At this time, the computing device 100 may select a recommended test for testing the function selected as the function of interest, generate test cases corresponding to the recommended test, and determine the number of test cases to be generated based on the number of occurrences of issues. there is. For example, the computing device 100 may select one recommendation test for the first function when the number of occurrences of issues of the first function selected as the function of interest is less than the first number of times, and select one recommendation test corresponding to the one recommendation test. You can create test cases. In addition, the computing device 100 may select two recommendation tests for the first function when the number of occurrences of issues of the first function selected as the function of interest is equal to or greater than the first number and is less than the second number, and the two recommendation tests You can create two corresponding test cases. In addition, the computing device 100 may select three or more recommended tests for the first function when the number of occurrences of issues of the first function selected as the function of interest is equal to or greater than the second number of times, and selects three or more recommended tests corresponding to the three or more recommended tests. You can create test cases. However, it is not limited thereto.

In various embodiments, the computing device 100 may perform a test for the same test object (software or at least one function among a plurality of functions included in the software) from two or more different users, for the same test object. Test cases corresponding to different types of tests may be generated for each of two or more different users so that each of two or more different users performs different types of tests.

In various embodiments, the computing device 100 may set a test degree (test importance) for a test target in advance, and for a test target having a low test importance, different types of tests may be performed by a plurality of users. Test cases corresponding to different types of tests can be created, and test cases corresponding to the same tests can be created so that multiple users can perform the same types of tests for test subjects with high test importance.

In various embodiments, the computing device 100 may automatically generate test cases for testing a test target based on big data analysis or automatically generate test cases for testing a test target based on an artificial intelligence model. . Hereinafter, it will be described in more detail with reference to FIGS. 7 and 8 .

7 is a flowchart illustrating a method of automatically generating test cases based on big data analysis, in various embodiments.

Referring to FIG. 7 , in step S510, the computing device 100 may build a test case database. Here, the test case database construction operation performed by the computing device 100 may be implemented in the same or similar form as the test case database construction operation performed in step S210 of FIG. 4 , but is not limited thereto.

In step S520, the computing device 100 corresponds to a test target (eg, an object to be tested by a user, software or at least one function among a plurality of functions included in the software) from the test case database built through step S510. Multiple test cases can be extracted. Here, the plurality of test case extraction operations performed by the computing device 100 may be implemented in the same or similar form as the plurality of test case extraction operations performed in step S220 of FIG. 4 , but are not limited thereto.

In step S530, the computing device 100 may automatically generate test cases for testing the test target by big data analysis of the plurality of test cases extracted through step S520.

More specifically, first, the computing device 100 may extract patterns of a plurality of test cases by big data analysis on a plurality of test cases extracted from a test case database. For example, the computing device 100 analyzes the big data of a plurality of test cases corresponding to a specific function to determine what type of test was performed for a specific function, what kind of test was performed in what way, and/or what type of test was performed. Patterns, such as how many tests have been performed, that is, test case generation patterns for specific functions can be extracted as feature data for a plurality of test cases.

Thereafter, the computing device 100 may generate a test case for testing the test target based on feature data (test case generation pattern) extracted through big data analysis. For example, when the computing device 100 analyzes big data on a plurality of test cases corresponding to a specific function and determines that the first test and the second test have been performed for the specific function, the first test and the second test are performed. may be selected as a recommended test, and a first test case and a second test case corresponding to each of the first test and the second test selected as the recommended test may be generated.

8 is a flowchart illustrating a method of automatically generating a test case based on a test case generation model, in various embodiments.

Referring to FIG. 8 , in step S610, the computing device 100 may generate a test case generation model. Here, the test case generation model generation operation performed by the computing device 100 may be implemented in the same or similar form as the test case generation model generation operation performed in step S310 of FIG. 5 , but is not limited thereto.

In step S620, the computing device 100 may output result data through the test case generation model generated through step S610, and may generate a test case based on the output result data.

For example, the computing device 100 may automatically generate a test case corresponding to the outputted recommended test when a recommended test for the test object is output as information on the test object is input to the test case generation model.

As another example, the computing device 100 converts the output test cases into test cases for testing the test object when one or more test cases for the test object are output as information on the test object is input to the test case generation model. can be set

As another example, when a plurality of test cases for the test target are output as information on the test target is input to the test case generation model, the computing device 100 sets each of the plurality of test cases to a test for testing the test target. It may be set as a case, but is not limited thereto, and a pattern may be extracted by analyzing a plurality of test cases, a recommended test may be selected based on the extracted pattern, and a test case corresponding to the recommended test may be automatically generated. can

Again, referring to FIG. 6 , in step S430, the computing device 100 may provide the test case generated through step S420 to the user.

In various embodiments, when a plurality of test cases are generated for one test object as a result of obtaining test requests for one test object from a plurality of users, the computing device 100 may generate a plurality of tests according to the type of test. By classifying cases and distributing each of a plurality of classified test cases to a plurality of users, each user can perform the same type of test, thereby improving test task efficiency.

Next, referring to FIG. 9 , a test task assignment method for quality assurance of software performed by the computing device 100 will be described.

9 is a flow chart illustrating a method for allocating test tasks as a solution for software quality assurance, in various embodiments.

Referring to FIG. 9 , in various embodiments, the computing device 100 is a solution for software quality assurance, assigning a test task for software quality assurance to a plurality of workers, but performing the test task based on attributes of the test task. You can assign testing tasks to suitable users to perform them.

In step S710, the computing device 100 may create a test task for software quality assurance.

In various embodiments, the computing device 100 may perform a test for at least one function among software or a plurality of functions included in the software, and for software or at least one function among a plurality of functions included in the software. A test case can be created, and a test task instructing to perform a test according to the created test case can be created.

Here, the test case for the test target (software or at least one function among a plurality of functions included in the software) is directly generated by the operator through the UI provided by the computing device 100 (eg, steps S110 to S130 of FIG. 3 ). step) or automatically generated by the computing device 100 (eg, step S420 of FIG. 6), but is not limited thereto.

In step S720, the computing device 100 may allocate the test task created through step S710 to the operator.

In various embodiments, the computing device 100 may assign a test task to at least one worker among a plurality of pre-registered workers.

Here, the plurality of pre-registered workers are testers capable of performing tests on software or a plurality of functions included in the software, and may include a plurality of first workers and a plurality of second workers.

Also, here, the plurality of first workers are professional software testers pre-registered in the professional software tester (Software Tester) manpower pool, for example, employees employed by a company that performs testing for software quality assurance, or a software development company. It may refer to an employee belonging to a team that performs testing tasks for software quality assurance within the company.

In addition, here, the plurality of second workers are testers pre-registered in the Gig worker manpower pool, for example, employed by a company that performs testing for software quality assurance or software quality assurance within a software development company. It may refer to an ultra-short-term worker who does not belong to a team that performs test tasks for software and performs one-time software test tasks through a short-term contract. However, it is not limited thereto.

In various embodiments, the computing device 100 may allocate a plurality of test tasks to each of a plurality of workers and then recognize at least one rejected test task from among the plurality of tests. The computing device 100 may obtain a reason for refusal from the refusal worker who rejected the allocation of the test task. In addition, the computing device 100 may allocate at least one rejection test task to another worker based on the reason for rejection.

Specifically, when allocating at least one rejection test task to another worker, if the reason for rejection is simple rejection, the computing device 100 may assign it to the other worker without an additional reward. In addition, the computing device 100 may impose a penalty in which assignment of test tasks is limited by a preset number of times to the rejected worker.

Meanwhile, when allocating at least one rejection test task to another worker, the computing device 100 may determine the difficulty level of the at least one rejection test task when the reason for rejection is not simple rejection. In addition, the computing device 100 may grant additional rewards corresponding to task difficulty to at least one rejection test task. In addition, the computing device 100 notifies the gig worker QA platform (a platform for managing a gig worker manpower pool in which a plurality of second workers are registered) of at least one rejection test task to which an additional reward has been granted, and at least one rejection test task. It can be assigned to another second worker who wishes to process the test work.

That is, even if the test task is rejected, the computing device 100 of the present invention can process the QA task by assigning the rejected test task to another worker through various methods (eg, reassignment or providing additional rewards), QA business continuity can be guaranteed.

In various embodiments, the computing device 100 may select at least one worker from among a plurality of pre-registered workers based on attributes of the test task, and allocate the test task to the selected at least one worker. Hereinafter, it will be described in more detail with reference to FIGS. 10 and 11 .

10 is a flowchart illustrating a method of allocating test tasks according to difficulty levels, in various embodiments.

Referring to FIG. 10 , in step S810, the computing device 100 may determine the level of difficulty of a test task for performing a test on a test subject.

In various embodiments, the computing device 100 may define in advance the level of difficulty of test tasks for each test type, analyze test cases included in test tasks to be allocated to workers, and determine test types corresponding to the test tasks. The difficulty level of the test task may be determined by determining the difficulty level of the determined test type based on the difficulty level of the test task for each test type defined in advance.

In various embodiments, computing device 100 may adjust the difficulty of a test task based on a deadline for the test task. In general, even if the test type is the same, the shorter the deadline of the test task, the higher the perceived difficulty of the test task. The difficulty level of the task can be raised, and if the deadline for the test task is greater than the standard deadline, the difficulty level of the test task can be lowered.

In various embodiments, when a plurality of test cases are included in a test task for performing a test on a test target, the computing device 100 analyzes each of the plurality of test cases to determine a plurality of test cases corresponding to each of the plurality of test cases. A test type may be determined, a plurality of difficulty levels for each of a plurality of test types may be determined based on the level of difficulty of the test task for each test type defined in advance, and a level of difficulty for the test task may be determined based on the plurality of levels of difficulty. can For example, the computing device 100 may determine an average of a plurality of difficulties as the difficulty of the test task. However, the present invention is not limited thereto, and the computing device 100 may determine the highest level of difficulty among a plurality of levels of difficulty as the level of difficulty of the test task.

At this time, the computing device 100 may adjust the difficulty of a test task including a plurality of test cases based on the number of test cases included in the test task.

In step S820, the computing device 100 may determine whether the difficulty level of the test task is greater than or equal to the standard difficulty level by comparing the difficulty level of the test task determined in step S810 with the standard difficulty level.

In step S830, the computing device 100 may allocate the test task to a first worker (professional software tester) when it is determined that the difficulty of the test task is equal to or greater than the standard difficulty level through step S820.

In various embodiments, the computing device 100 sequentially starts with the first worker performing the test type corresponding to the test task the most among the plurality of first workers based on the test performance history of each of the plurality of first workers. Test tasks may be assigned to n first workers by selecting them.

In various embodiments, the computing device 100 may post test task request content for test task assignment, and obtain test task request requests from a plurality of first workers through the posted test task request content; A test task may be assigned by selecting at least one first operator from among a plurality of first operators who have requested a test task request.

For example, the computing device 100 may sequentially select n first workers from among a plurality of first workers, starting with a first worker who requested a test task request first, and allocate test tasks.

In various embodiments, the computing device 100 selects first workers capable of performing a test task based on test work schedules of a plurality of first workers and a deadline for a test task to be assigned to the workers, and selects first workers capable of performing the test task. Test tasks may be assigned to n first workers among the workers by randomly selecting them.

In various embodiments, the computing device 100 assigns a test task to at least one second worker among a plurality of pre-registered second workers when there is no first worker to be assigned a test task among a plurality of first workers, , By matching the at least one second operator with the specific first operator, the specific first operator can verify the test performance result of the at least one second operator.

In step S840, the computing device 100 may allocate the test task to a second worker (geek worker) when it is determined that the difficulty of the test task is less than the standard difficulty level through step S820.

In various embodiments, the computing device 100 sequentially starts with the second worker performing the test type corresponding to the test task the most among the plurality of second workers, based on the test performance history of each of the plurality of second workers. Test tasks may be assigned to n second workers by selecting them.

In various embodiments, the computing device 100 may post test task request content for test task assignment, and obtain test task request requests from a plurality of second workers through the posted test task request content; A test task may be assigned by selecting at least one second operator from among a plurality of second operators who have requested a test task request. For example, the computing device 100 may sequentially select n second workers from among a plurality of second workers, starting with a second worker who first requested a test task request, and allocate test tasks.

In various embodiments, the computing device 100 selects second workers capable of performing the test task based on test work schedules of a plurality of second workers and a deadline of the test task to be assigned to the workers, and selects the selected second workers. Test tasks may be assigned to n second workers among the workers by randomly selecting them.

11 is a flowchart illustrating a method of allocating test tasks according to types, in various embodiments.

Referring to FIG. 11 , in step S910 , the computing device 100 may determine the type of a test task for performing a test on a test target. For example, the computing device 100 may define a test task type for each test type in advance, analyze a test case included in the test task, determine a test type corresponding to the test task, and determine a test type corresponding to the test task. A type corresponding to the type of test may be determined based on the type of test task for each type.

For example, the computing device 100 may define a task function level table in advance, and based on the test cases included in the test task, the test cases included in the test task correspond to task function level 1 and task function level 2. In this case, the type of test task can be classified as a simple task, and if it corresponds to the task function level 3 and the task function level 4, the type of test task can be classified as a specialized task.

In various embodiments, the computing device 100 may classify the type of test task as a specialized task when the execution time of the test case included in the test task exceeds a preset time or exceeds a preset number of steps, When the execution time of test cases included in the test task is equal to or less than the preset time or equal to or less than the preset number of steps, the type of test task may be classified as a simple task. For example, if the execution time of the test case exceeds 30 minutes or exceeds 30 steps, the computing device 100 may classify the corresponding test task type as a specialized task. Meanwhile, when the execution time of the test case is 30 minutes or less or 30 steps or less, the computing device 100 may classify the type of test task as a simple task.

In various embodiments, the computing device 100 may classify the type of test task as a specialized task when a specific keyword is included in sentences for describing test cases included in the test task.

Here, the specific keyword may be a word that is included a predetermined number of times or more among words included in a sentence included in a test case of a rejection test task assigned to a worker for a predetermined period of time and then rejected by the worker. For example, a specific keyword may be a word included more than 30 times in a test case included in a rejected test task in the last month.

In step S920, the computing device 100 may determine whether the type of test task determined in step S910 is a preset type. For example, computing device 100 may determine the type of testing task to be performed by a professional software tester.

In step S930, the computing device 100 goes through step S920 when it is determined that the type of test task is a preset type, that is, the type of test task to be performed by a professional software tester (eg, classified as a professional task). tested task), the test task may be assigned to the first operator.

In various embodiments, the computing device 100 may select at least one first worker from among a plurality of first workers and assign the test task. Here, the operation of selecting at least one first worker and allocating the test task may be implemented in the same or similar form to the operation performed in step S830 of FIG. 10 , but is not limited thereto.

In step S940, the computing device 100 goes through step S920 when it is determined that the type of test task is not a predetermined type, that is, the type of test task can be performed by all workers (eg, a test classified as a simple task). task), the test task may be assigned to the first operator.

In various embodiments, when it is determined that the type of test task is a task that can be performed by all workers, the computing device 100 selects at least one second worker from among a plurality of second workers and assigns the test task. .

At this time, the computing device 100 selects at least one first worker from among a plurality of previously registered first workers and assigns the test task when there is no second worker among the plurality of second workers to be assigned the test task. can

Again, referring to FIG. 9 , in step S730, the computing device 100 may obtain a test performance result from the operator in response to allocating the test task to the operator through step S720. For example, the computing device 100 may be connected to the user terminal 200 of each of a plurality of workers, and collect test performance results obtained as each of the plurality of workers performs a test task through the user terminal 200. .

In various embodiments, the computing device 100 obtains a plurality of test execution results corresponding to each of the plurality of test tasks from the plurality of workers when assigning a plurality of test tasks to each of a plurality of workers for one test target. In addition, a test progress status and test result for a test target may be derived and provided by collecting a plurality of acquired test performance results. For example, as shown in FIGS. 21 to 26 , the computing device 100 may provide a dashboard UI that aggregates and outputs a plurality of test execution results obtained from a plurality of workers, but is not limited thereto.

In various embodiments, when a plurality of test tasks for testing one test object are generated, the computing device 100 allocates each of the plurality of test tasks to a plurality of second workers, but at least for one test object. By matching one first operator, a test performance result obtained as a plurality of second operators perform the test may be verified through the at least one first operator.

For example, the computing device 100 provides a plurality of test execution results derived as each of a plurality of second workers performs a plurality of test tasks to at least one first worker, and provides the plurality of test tasks from the at least one first worker. Verification of a plurality of test execution results may be performed by obtaining feedback (eg, positive feedback or negative feedback) on test execution results.

In this case, when obtaining negative feedback on at least one test performance result among a plurality of test performance results, the computing device 100 sends the second operator who inputs the at least one test performance result for which the negative feedback is obtained. You may request a redo of the work.

In various embodiments, the computing device 100, when it is determined that an issue with the software has occurred based on a test performance result derived as the second worker performs the first test task assigned to the second worker, generates A second test task (additional test task) corresponding to the identified issue may be created and reassigned to a second worker, and a test execution result obtained as the second worker performs the second test task may be obtained.

In this case, the computing device 100 determines that the same software issue reoccurs based on the test result obtained as the second operator performs the second test task, the first test task and the second test. By assigning the task to the first worker, it is possible to conduct a test for the issue by a more professional tester.

In various embodiments, the computing device 100 may provide a predetermined reward to the second worker in response to the second worker completing performance of a specific test task. At this time, since the first worker is an employee who is paid by a company that performs testing for software quality assurance or a software development company, separate compensation for the test work may not be provided, but is not limited thereto, and the second worker is not limited thereto. Similar to the worker (method of FIG. 12 to be described later), when the first worker completes the test task, a reward for performing the test task may be provided to the first operator. Hereinafter, it will be described in more detail with reference to FIG. 12 .

12 is a flowchart illustrating a method of providing a reward according to test performance to an operator, in various embodiments.

Referring to FIG. 12 , in step S1010 , the computing device 100 may determine the ability of the second worker to perform the test.

Here, the operation of determining the ability to perform the test for the second worker is performed in response to obtaining a registration request for the gig worker manpower pool from the second worker who is not registered in the gig worker manpower pool, that is, the gig worker manpower pool It may be performed for the purpose of registering a second worker who is not registered in the gig worker manpower pool, but is not limited thereto.

More specifically, first, the computing device 100 may provide a training test task for evaluating a test performance capability to a second operator.

Here, the training test task for evaluating test performance capability may mean at least one test task among a plurality of test tasks pre-assigned to the first operator, that is, a test task having a history performed by a professional software tester, Not limited to this.

Thereafter, the computing device 100 may obtain a test execution result derived as the second worker performs the training test task, and may calculate a similarity between the obtained test performance result and the correct answer of the training test task.

Here, the correct answer of the training test task may mean a test execution result derived as the first worker performs at least one test task. That is, when the training test task is a first test task pre-allocated to the first worker, the correct answer of the training test task may be a test execution result derived as the first worker performs the first test task.

Here, as a method for calculating the similarity between different test execution results, various techniques are known, and these known techniques can be selectively applied (eg, from a second operator based on a Jaccard similarity calculation method). A method for calculating the ratio of common information (intersection) among all information (union) included in the acquired test performance results and the correct answers of the training test task, etc.), in this specification, the similarity between the test performance results and the correct answers of the training test task is calculated The specific method for doing this is not limited.

Thereafter, the computing device 100 may evaluate the test performance capability of the second operator based on the calculated similarity. For example, the computing device 100 sets a level proportional to the degree of similarity (eg, 1 to 100 levels) or sets a level corresponding to the level (eg, 1 to 5 grades) as a test performance capability for the second worker. can be set

In step S1020 , the computing device 100 may provide a reward in response to the completion of the specific test task by the second worker.

In various embodiments, the computing device 100 may determine a reward size for a specific test task in advance, and when the second worker performs the specific test task, the computing device 100 provides a reward of a predetermined size in response to the specific test task. It can be provided to a second worker. In this case, the computing device 100 may adjust the size of the reward based on the second worker's ability to perform the test.

For example, when the second worker's test performance ability is lower than the first grade or lower than the first level, the computing device 100 may provide the second worker with only a reward of a predetermined size in response to a specific test task. In addition, when the second worker's test performance ability is equal to or greater than the first level and less than the second level, or greater than or equal to the first level and less than the second level, the computing device 100 provides compensation of a predetermined size in response to a specific test task and a first size compensation. Additional compensation of may be provided to the second worker. In addition, the computing device 100 adds a compensation of a predetermined size in response to a specific test task and a second size greater than the first size when the second worker has a second level or higher (third level) or a second level or higher. Compensation may be provided to the second worker.

As another example, the computing device 100 may adjust the size of the reward based on the difficulty of the test task and the ability of the second worker to perform the test. For example, the computing device 100 has a "middle level" difficulty level of the test task (e.g., a level of difficulty suitable for a second operator whose ability to perform the test is greater than or equal to the first level and less than the second level or greater than or equal to the first level and less than the second level). ), when the second worker's test performance capability is less than the first level or less than the first level, a reward having a predetermined size and additional compensation may be provided to the second worker in response to a specific test task. In addition, the computing device 100 determines that when the difficulty level of the test task is "Middle level", the second operator's test performance ability is greater than or equal to the first level and less than the second level, or greater than or equal to the first level and less than the second level. In response to a specific test task, only a predetermined amount of compensation may be provided to the second worker. Meanwhile, the computing device 100 may perform a specific test task when the difficulty level of the test task is "middle level" and the second worker's ability to perform the test is the second level or higher (third level) or higher than the second level. Corresponding to , at least a portion of the compensation having a predetermined size may be deducted and provided to the second worker.

Here, the compensation provided to the second worker may be a monetary consideration (cost of performing the test task) provided for performing the test task, but is not limited thereto, and the reward provided to the second operator is the second worker performing the test. It can be points (scores or experience points) to improve abilities.

For example, the computing device 100 performs the test task as the second operator by providing a predetermined size of experience value (experience value proportional to the difficulty level) along with monetary compensation as the second operator performs a specific test task. The more you do, the more you can build an environment that can raise the level corresponding to the second worker's ability to perform the test, and accordingly, the second worker who repeatedly performs a lot of test work raises the level a lot to receive more additional rewards. environment can be built.

In various embodiments, the computing device 100 may determine a size of a reward to be provided to the second worker based on the second worker's ability to perform the test, and when the second worker performs a specific test task, the second worker It is possible to provide a reward of a size determined based on the ability to perform the test. For example, when the second worker's ability to perform the test is lower than the first grade or lower than the first level, the computing device 100 may determine the size of the compensation for the second worker as the first size. In addition, the computing device 100 sets the size of the compensation for the second worker to a second level greater than the first level when the second worker's test performance ability is equal to or greater than the first level and less than the second level or greater than or equal to the first level and less than the second level. size can be determined. In addition, when the second worker's test performance ability is the second level or higher (third level) or higher than the second level, the computing device 100 sets the compensation for the second worker to a third size greater than the second size. can decide

In various embodiments, when the same test task is assigned to two or more second workers, the computing device 100 provides the same amount of compensation to each of the two or more second workers, but completes the test task of each of the two or more second workers. The amount of compensation may be provided differently based on time. For example, the computing device 100 may provide compensation of the same size to two or more second workers assigned to the same test task, but may sequentially provide additional rewards of different sizes according to the order in which the test tasks are completed.

In various embodiments, the computing device 100 generates an issue when it is determined that an issue with software has occurred based on a test performance result derived as the second worker performs a test task assigned to the second worker. Compensation according to may be provided to the second worker. At this time, when the test task assigned to the second worker is a test task generated according to a test case directly created by the second worker, that is, the computing device 100 determines the test target according to the test case directly created by the second worker. When an issue with the software is generated as a result of testing, additional compensation may be provided to the second worker in addition to the compensation for the occurrence of the issue.

In various embodiments, the computing device 100 may create and assign an inspection task to the first operator to inspect the test performance result obtained as the second operator performs the test task assigned to the second operator, As the inspection task is assigned to the first worker, a quality level for the test performance result (the result of the second worker) may be obtained from the first worker, and a reward may be provided to the second worker based on the quality level.

The above-described method for providing a solution for software quality assurance has been described with reference to a flowchart shown in the drawings. For brief explanation, the method for providing a solution for software quality assurance has been illustrated and described as a series of blocks, but the present invention is not limited to the order of the blocks, and some blocks are performed in a different order than shown and performed herein. or can be performed concurrently. In addition, new blocks not described in the present specification and drawings may be added, or some blocks may be deleted or changed.

Although the embodiments of the present invention have been described with reference to the accompanying drawings, those skilled in the art to which the present invention pertains can be implemented in other specific forms without changing the technical spirit or essential features of the present invention. you will be able to understand Therefore, it should be understood that the embodiments described above are illustrative in all respects and not restrictive.

100: computing device
200: user terminal
300: external server
400: network

Claims (11)

In a method performed by a computing device,
Obtaining a test case (Test Case, TC) generation request for software quality assurance (Quality Assurance, QA) from a user; and
In response to the obtained test case creation request, providing a user interface (UI) for test case creation to the user,
Providing the user interface,
Providing guide information for generating test cases to the user;
The step of providing the guide information,
selecting one or more recommended tests for the at least one function when the user wants to create a test case for testing at least one function among a plurality of functions included in the software; and
As the guide information, guide information including information on the one or more selected recommended tests and information on a method for generating a test case corresponding to the one or more selected recommended tests may be provided, or the one or more selected recommended tests may be provided. Providing sample test cases corresponding to
The step of providing the guide information,
obtaining information about a terminal performing a test;
determining a test range for the terminal based on the attribute of the terminal; and
Selecting a recommended test for the at least one function based on the determined test range;
The step of providing the guide information,
When a plurality of first test cases corresponding to a test object, wherein the test object is at least one function among a plurality of functions included in the software, are generated from the user, a pre-constructed test case database - the pre-constructed test case database The test case database classifies and stores a plurality of test cases previously created to test a plurality of software and a plurality of functions included in each of the plurality of software - a plurality of second test cases corresponding to the test target extracting;
Patterns of the extracted second test cases are extracted through big data analysis on the extracted second test cases, and the generated first test cases are verified based on the extracted patterns. performing; and
Providing guide information to the user based on a result of verifying the generated plurality of first tests;
The step of verifying the plurality of first test cases,
calculating a plurality of unit similarities for each of a plurality of items included in the plurality of first test cases and a plurality of items included in the plurality of second test cases;
calculating an average value of the plurality of unit similarities as similarities between the plurality of first test cases and the plurality of second test cases; and
When the calculated similarity is less than a predetermined reference similarity, providing guide information for guiding a modification request for the plurality of first test cases,
The step of verifying the plurality of first test cases,
extracting a pattern of the plurality of first test cases, which includes information about a ratio and a test order for each test type included in the plurality of first test cases;
extracting a pattern of the plurality of second test cases, which includes information about a ratio and a test order for each test type included in the plurality of second test cases;
The patterns of the plurality of first test cases are compared with the patterns of the plurality of second test cases, and when the patterns of the plurality of first test cases and the patterns of the plurality of second test cases are different, the patterns of the plurality of test cases are different. Providing guide information for guiding a modification request for the first test case;
Obtaining the test case creation request,
Including the step of determining the importance for the test object,
The step of providing the guide information,
When a test case generation request for the same test object is obtained from a plurality of users, the same guide information is provided so that the plurality of users create the same test case when the importance of the test object is greater than or equal to a preset reference value, and the test Providing different guide information so that the plurality of users create different test cases when the importance of the object is less than a preset reference value,
Allocating a test task for the generated test case to at least one operator among a plurality of previously registered operators;
The plurality of previously registered workers,
Including a plurality of first workers pre-registered in the professional software tester manpower pool and a plurality of second workers pre-registered in the gig worker manpower pool,
The step of assigning the test task,
Providing a predetermined reward to one of the plurality of second workers in response to completion of a specific test task assigned to the one of the second workers; Including,
The step of providing the predetermined reward,
When two or more second workers among the plurality of second workers complete the performance of the same test task, providing rewards of different sizes to the two or more workers based on the test task completion order of the two or more workers;
When it is determined that an issue with software has occurred based on a test performance result derived as the one second worker performs a specific test task assigned to the one or more second workers, the one or more Compensation is provided to the second worker according to the occurrence of an issue, but if the specific test task assigned to any one second worker is a test task created according to the test case created by the one or more second workers, any one of the above providing additional compensation to one second worker in addition to compensation according to the occurrence of the issue; and
By creating an inspection task for inspecting test performance results obtained as the one second operator performs a specific test task assigned to the one or more second operators, one of the plurality of first operators performs a test task. operator, and as the generated inspection task is assigned to any one first operator, a quality level for the test execution result is obtained from the one first operator, and based on the obtained quality level Comprising the step of providing a reward to any one of the second workers,
How to provide a user-customized test case creation guide for software quality assurance. delete According to claim 1,
The step of selecting one or more recommended tests,
determining a test performance capability of the user based on a test performance history of the user, and determining a test difficulty level for the user based on the determined test performance capability; and
Selecting a recommended test for the at least one function based on the determined test difficulty,
How to provide a user-customized test case creation guide for software quality assurance. delete According to claim 1,
Building a test case database by collecting a plurality of pre-generated test cases to test a plurality of software and a plurality of functions included in each of the plurality of software, and classifying and storing the collected plurality of test cases Including more,
The step of providing the guide information,
extracting a plurality of test cases corresponding to a test object, wherein the test object is at least one function among a plurality of functions included in the software, from the constructed test case database;
extracting patterns of the plurality of extracted test cases through big data analysis of the plurality of extracted test cases; and
Based on the extracted pattern, providing guide information for generating a test case corresponding to the test target,
How to provide a user-customized test case creation guide for software quality assurance. According to claim 1,
Further comprising generating a test case generation model by learning a plurality of pre-generated test cases as learning data to test a plurality of software and a plurality of functions included in each of the plurality of software,
The step of providing the guide,
extracting one or more test cases by inputting information about a test object, wherein the test object is at least one function among a plurality of functions included in the software, to the generated test case generation model; and
Providing the one or more extracted test cases to the user as sample test cases for the test object.
How to provide a user-customized test case creation guide for software quality assurance. delete According to claim 1,
The step of providing the guide information,
If it is determined that an issue with the software has occurred based on the test results obtained by the user performing a test for the software according to a previously created test case, one or more additional tests for the generated issue selecting; and
As the guide information, guide information including information on the one or more selected additional tests and information on a method for generating a test case corresponding to the one or more selected additional tests may be provided, or the one or more selected additional tests may be provided. Including providing a sample test case corresponding to
How to provide a user-customized test case creation guide for software quality assurance. delete processor;
network interface;
Memory; and
A computer program loaded into the memory and executed by the processor,
The computer program,
An instruction for obtaining a request for generating a test case (TC) for software quality assurance (QA) from a user; and
In response to the obtained test case creation request, an instruction for providing a user interface (UI) for test case creation to the user,
The instruction providing the user interface,
Includes instructions for providing guide information for generating test cases to the user;
The instruction providing the guide information,
an instruction for selecting one or more recommended tests for the at least one function when the user wants to generate a test case for testing at least one function among a plurality of functions included in the software; and
As the guide information, guide information including information on the one or more selected recommended tests and information on a method for generating a test case corresponding to the one or more selected recommended tests may be provided, or the one or more selected recommended tests may be provided. Includes instructions that provide sample test cases corresponding to;
The instruction providing the guide information,
an instruction for obtaining information about a terminal performing a test;
instructions for determining a test range for the terminal based on the attributes of the terminal; and
Includes instructions for selecting a recommended test for the at least one function based on the determined test range;
The instruction providing the guide information,
When a plurality of first test cases corresponding to a test object, wherein the test object is at least one function among a plurality of functions included in the software, are generated from the user, a pre-constructed test case database - the pre-constructed test case database The test case database classifies and stores a plurality of test cases previously created to test a plurality of software and a plurality of functions included in each of the plurality of software - a plurality of second test cases corresponding to the test target instruction to extract;
Patterns of the extracted second test cases are extracted through big data analysis on the extracted second test cases, and the generated first test cases are verified based on the extracted patterns. instruction to perform; and
An instruction for providing guide information to the user based on a result of verifying the generated plurality of first tests;
The instruction for performing the verification of the plurality of first test cases,
an instruction for calculating a plurality of unit similarities for each of a plurality of items included in the plurality of first test cases and a plurality of items included in the plurality of second test cases;
an instruction for calculating an average value of the plurality of unit similarities as similarities between the plurality of first test cases and the plurality of second test cases; and
An instruction for providing guide information for guiding a modification request for the plurality of first test cases when the calculated similarity is less than a preset reference similarity,
The instruction for performing the verification of the plurality of first test cases,
an instruction for extracting a pattern of the plurality of first test cases, including information about a ratio and a test order for each test type included in the plurality of first test cases;
an instruction for extracting a pattern of the plurality of second test cases, which includes information about a ratio and a test order for each test type included in the plurality of second test cases;
The patterns of the plurality of first test cases are compared with the patterns of the plurality of second test cases, and when the patterns of the plurality of first test cases and the patterns of the plurality of second test cases are different, the patterns of the plurality of test cases are different. Includes instructions for providing guide information for guiding a modification request for the first test case;
The instruction for obtaining the test case creation request,
contains instructions for determining the importance of the test object;
The instruction providing the guide information,
When a test case generation request for the same test object is obtained from a plurality of users, the same guide information is provided so that the plurality of users create the same test case when the importance of the test object is greater than or equal to a preset reference value, and the test Including an instruction for providing different guide information so that the plurality of users create different test cases when the importance of the object is less than a preset reference value,
Further comprising an instruction for assigning a test task for the generated test case to at least one operator among a plurality of previously registered operators,
The plurality of previously registered workers,
Including a plurality of first workers pre-registered in the professional software tester manpower pool and a plurality of second workers pre-registered in the gig worker manpower pool,
The instructions for allocating the test task are:
Instructions for providing a predetermined reward to any one of the plurality of second workers in response to completion of a specific test task assigned to the one of the second workers Including,
The instruction for providing the predetermined reward,
instructions for providing different sizes of rewards to the two or more workers based on the test task completion order of the two or more workers, when two or more second workers among the plurality of second workers complete the same test task;
When it is determined that an issue with software has occurred based on a test performance result derived as the one second worker performs a specific test task assigned to the one or more second workers, the one or more Compensation is provided to the second worker according to the occurrence of an issue, but if the specific test task assigned to any one second worker is a test task created according to the test case created by the one or more second workers, any one of the above an instruction for providing additional compensation to one second worker in addition to compensation according to occurrence of the issue; and
By creating an inspection task for inspecting test performance results obtained as the one second operator performs a specific test task assigned to the one or more second operators, one of the plurality of first operators performs a test task. operator, and as the generated inspection task is assigned to any one first operator, a quality level for the test execution result is obtained from the one first operator, and based on the obtained quality level Including instructions for providing a reward to any one of the second workers,
A computing device that performs a method of providing a user-customized test case creation guide for software quality assurance. Combined with a computing device,
Obtaining a test case (Test Case, TC) generation request for software quality assurance (Quality Assurance, QA) from a user; and
In response to the obtained test case creation request, providing a user interface (UI) for test case creation to the user,
Providing the user interface,
Providing guide information for generating test cases to the user;
The step of providing the guide information,
selecting one or more recommended tests for the at least one function when the user wants to create a test case for testing at least one function among a plurality of functions included in the software; and
As the guide information, guide information including information on the one or more selected recommended tests and information on a method for generating a test case corresponding to the one or more selected recommended tests may be provided, or the one or more selected recommended tests may be provided. Providing sample test cases corresponding to
The step of providing the guide information,
obtaining information about a terminal performing a test;
determining a test range for the terminal based on the attribute of the terminal; and
Selecting a recommended test for the at least one function based on the determined test range;
The step of providing the guide information,
When a plurality of first test cases corresponding to a test object, wherein the test object is at least one function among a plurality of functions included in the software, are generated from the user, a pre-constructed test case database - the pre-constructed test case database The test case database classifies and stores a plurality of test cases previously created to test a plurality of software and a plurality of functions included in each of the plurality of software - a plurality of second test cases corresponding to the test target extracting;
Patterns of the extracted second test cases are extracted through big data analysis on the extracted second test cases, and the generated first test cases are verified based on the extracted patterns. performing; and
Providing guide information to the user based on a result of verifying the generated plurality of first tests;
The step of verifying the plurality of first test cases,
calculating a plurality of unit similarities for each of a plurality of items included in the plurality of first test cases and a plurality of items included in the plurality of second test cases;
calculating an average value of the plurality of unit similarities as similarities between the plurality of first test cases and the plurality of second test cases; and
When the calculated similarity is less than a predetermined reference similarity, providing guide information for guiding a modification request for the plurality of first test cases,
The step of verifying the plurality of first test cases,
extracting a pattern of the plurality of first test cases, which includes information about a ratio and a test order for each test type included in the plurality of first test cases;
extracting a pattern of the plurality of second test cases, which includes information about a ratio and a test order for each test type included in the plurality of second test cases;
The patterns of the plurality of first test cases are compared with the patterns of the plurality of second test cases, and when the patterns of the plurality of first test cases and the patterns of the plurality of second test cases are different, the patterns of the plurality of test cases are different. Providing guide information for guiding a modification request for the first test case;
Obtaining the test case creation request,
Including the step of determining the importance for the test object,
The step of providing the guide information,
When a test case generation request for the same test object is obtained from a plurality of users, the same guide information is provided so that the plurality of users create the same test case when the importance of the test object is greater than or equal to a preset reference value, and the test Providing different guide information so that the plurality of users create different test cases when the importance of the object is less than a preset reference value,
Allocating a test task for the generated test case to at least one operator among a plurality of previously registered operators;
The plurality of previously registered workers,
Including a plurality of first workers pre-registered in the professional software tester manpower pool and a plurality of second workers pre-registered in the gig worker manpower pool,
The step of assigning the test task,
Providing a predetermined reward to one of the plurality of second workers in response to completion of a specific test task assigned to the one of the second workers; Including,
The step of providing the predetermined reward,
When two or more second workers among the plurality of second workers complete the performance of the same test task, providing rewards of different sizes to the two or more workers based on the test task completion order of the two or more workers;
When it is determined that an issue with software has occurred based on a test performance result derived as the one second worker performs a specific test task assigned to the one or more second workers, the one or more Compensation is provided to the second worker according to the occurrence of an issue, but if the specific test task assigned to any one second worker is a test task created according to the test case created by the one or more second workers, any one of the above providing additional compensation to one second worker in addition to compensation according to the occurrence of the issue; and
By creating an inspection task for inspecting test performance results obtained as the one second operator performs a specific test task assigned to the one or more second operators, one of the plurality of first operators performs a test task. operator, and as the generated inspection task is assigned to any one first operator, a quality level for the test execution result is obtained from the one first operator, and based on the obtained quality level A computer program stored in a recording medium readable by a computing device in order to execute a method for providing a user-customized test case generation guide for software quality assurance comprising providing a reward to any one of the second workers.

Images