JP5523525B2 - Test data generation apparatus, method and program having update access during test path - Google Patents

Description

  The present invention relates to a test data generation apparatus, method, and program having an update access during a test path, and more particularly to a functionality test that involves reading and updating operations of data stored in a DB (database). DATA GENERATION DEVICE, METHOD, AND PROGRAM FOR TESTING WITH UPDATE ACCESS DURING TEST PATH, FOR GENERATING A COMBINATION OF INPUT VALUES AND DB INITIAL STATE WHICH IS REQUIRED FOR DB UPDATE About.

  There are the following test data generation techniques for functional tests that involve an operation of reading data stored in a database. Here, the test data is a pair of the initial state of the database (hereinafter referred to as “DB initial state”) and the input value. To test the database application, to the input field of each screen at the time of test execution Is used as a data set to be entered in advance in the database.

  Conventionally, a method for generating a test case (including an initial DB state) (for example, refer to Non-Patent Document 1) using a precondition described for each test case as an input, and a software design information as an input, There is a method of extracting a precondition of the test case and generating a DB initial state that satisfies the precondition of the test case for each test case (for example, see Non-Patent Document 2).

Shoichiro Fujiwara, Kazuki Munakata, Asako Katayama, Yoshiharu Maeda, Kenji Oki, Tadahiro Uehara, Rieko Yamamoto, generation of web application test using smt solver, 50th anniversary commemoration of IPSJ (72nd) National Conference Proceedings, 2010. Omon Tanno, Akira Zhang, Takashi Hoshino: "Automatic generation of test database using design model", Transactions of Information Processing Society of Japan: Special Issue on Software Engineering, Vol. 53, No.2, pp. 566-577, 2012 .

  However, the above conventional technique can convert an update query (UPDATE) query into two equivalent SELECT queries, but if there are two or more SELECT queries, the number of records different from the planned number of records is returned. In addition, test cases with update access are always in one group per test case, that is, do not use the DB initial state. As a result, when update access occurs, the DB initial state is rewritten and cannot be reused.

  In addition, INSERT and DELETE queries can be converted into one equivalent SELECT query, but if there are INSERT and UPDATE queries after SELECT query on the test path, there will be two SELECT queries, There is a problem that the number of records different from the number of records is returned.

  Also, if the search condition space for the same column overlaps, using the above conventional method, records that differ from the number of records planned under the guard condition (integer arithmetic expression, integer comparison operator, etc.) on the test path There is a problem that the number of cases is returned. Moreover, since these technologies generate one DB initial state per test case, they can handle only SELECT access of DB definition (Persons) at most once. Therefore, there is a problem that the number of times of initial DB replacement is large every time the test is performed. For example, there are the input value definition and DB definition (Persons) shown in Fig. 1, and "SELECT * FROM Persons WHERE Age <= maxAge AND Age> = minAge" is given as the SELECT statement in the test case extracted from the processing flow diagram. If one SELECT statement is used, test data with two search result records can be obtained as shown on the right side of the figure. However, if there are multiple reference accesses and conditional branches for the same table (Persons), there is a problem that it cannot be handled.

  The present invention has been made in view of the above points, and in a test path capable of generating test data for a test that handles an UPDATE query and a DELETE query in addition to the SELECT query handled in the prior art. An object of the present invention is to provide a test data generation apparatus, method and program having update access.

In order to solve the above problems, the present invention (Claim 1) provides a database (DB) with update access during a test path for generating test data having update access in addition to reference access during the test path. A test data generation device having
A test case extraction means for extracting a test case from the inputted design information and storing it in the test case storage means;
When the test case is read from the test case storage unit and the last query type in the test path is an update query, the update query is converted into a reference query based on a condition according to the query type, Update query conversion means for storing in the test case storage means;
The test cases are read from the test case storage means, and test cases that can share the same initial DB state are grouped as test case groups so that there is no duplication in the records extracted by each SELECT statement of test cases belonging to the same group. , Test case grouping means for storing in the test case group set storage means,
Reading the test case group from the test case group set storage means, obtaining information of each test case of the test case group from the test case storage means, generating a constraint equation of the input variables of the test case, An input variable constraint expression generating means for storing in a constraint set of a test case group set storage means including a test case;
Obtain the test case group from the test case group set storage means, extract the DB table variable of the test case included in the test case group, determine the number of records of the DB table variable, and refer to the DB table variable A process for adding a SELECT query to a query group is repeated for the total number of search result records of each query, and a record arrangement determining unit that is added to a reference query group of DB table variables of the test case group set storage unit;
Said generating the constraint equation relating DB field variable test cases included in the test case groups, DB variable constraint expression generating means for adding the constraint set of the test case groups set storage unit of the test case group set storage unit,
Constraint equation solving means that solves the constraint expression stored in the test case group set storage means using an arbitrary solution and outputs the input value for each test case and the DB initial state sharing the test case as test data And having.

The present invention (Claim 2) provides the update query conversion means,
When the update query is an INSERT query, means for generating a SELECT query that guarantees uniqueness after inserting a record;
When the update query is an UPDATE query, means for generating a SELECT query that guarantees the presence of the update target record and does not cause duplicate unique keys after the update;
When the update query is a DELETE query, it includes means for generating a SELECT query that guarantees the existence of the deletion target.

Further, the present invention (Claim 3) is the test case grouping means,
When the test case to be grouped includes an update query, a method for adding the test case to the update query test case set, and when not including the update query to the reference query test case set,
The reference query test case set is grouped based on an input grouping parameter, and the updated query test case set is a test case group for one test case;
Means for arbitrarily selecting one test case from the test case group and substituting the DB table variable of the selected test case into the DB table variable of the test case group;

Further, the present invention (Claim 4), in the DB variable constraint expression generation means,
With reference to records arrangement table records arrangement table storage means, wherein the generating a record that meets the conditions of the WHERE clause SELECT statement references the DB record variable, refers to not record the record so as not to coincide with the condition in the WHERE clause Means for generating

  As described above, according to the present invention, it is necessary to select one record based on a condition such as ensuring that there is one record to be updated and that unique key duplication (resulting in an error) does not occur after the update. In addition to queries, by converting update queries, such as UPDATE, DELETE, UPDATE, and INSERT queries, to reference queries (SELECT queries), it is possible to test DB update access reliably, and update queries Test data can be generated for tests that handle.

  For each SELECT statement, records referenced by the SELECT statement generate records that meet the conditions of the WHERE clause, and records that are not referenced generate records so that they do not match the conditions of the WHERE clause. As a result, the test case (test path) that executes the subsequent SELECT statement according to the number of search result records of the immediately preceding SELECT statement is guaranteed. DB initial state that constitutes test data to be generated can be generated.

  Further, in the present invention, by grouping test cases that reuse the same DB initial state, it is possible to reduce the number of times the DB initial state is replaced during the test execution. Note that, for an update query, one DB initial state is set for one test case, but since the reference query is grouped, the number of replacements can be reduced in total.

It is an example of test case generation in the prior art. It is a figure which shows the outline | summary of the test data generation in one embodiment of this invention. It is a block diagram of the test data generation device in one embodiment of the present invention. It is an example of the DB definition input in one embodiment of this invention. It is an example of the test case (path | route) input in one embodiment of this invention. It is an example of the input value definition input in one embodiment of this invention. It is a flowchart of outline | summary operation | movement of the test data generation apparatus in one embodiment of this invention. It is a data structure stored in the test data group set memory | storage part in one embodiment of this invention. It is a flowchart of the detailed process of test case extraction in one embodiment of this invention. It is a storage example of the test case memory | storage part in one embodiment of this invention. It is a flowchart of the detailed process of the update type | system | group query update part in one embodiment of this invention. It is the example of conversion from the update type | system | group query in one embodiment of this invention to a reference type | system | group query. It is a flowchart of the detailed process of the test case grouping part in one embodiment of this invention. It is an example of operation | movement of the test case grouping part in one embodiment of this invention. It is a flowchart of the detailed process of the input variable constraint expression production | generation part in one embodiment of this invention. It is a flowchart of the detailed process of the record arrangement | positioning determination part in one embodiment of this invention. It is an example of operation | movement of the record arrangement | positioning determination part in one embodiment of this invention. It is a flowchart of detailed processing of the DB table variable constraint generator according to an embodiment of the present invention. It is a diagram illustrating the operation of the DB table variable constraint generator according to an embodiment of the present invention. It is an output example from the test data output part in one embodiment of this invention.

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

  In the present invention, as shown in FIG. 2, an input value definition, a test case (path), and a DB definition (in the present embodiment, a Persons table) are input as design information (XML). The test case performs reference access, conditional branch of C1, and update access (INSERT) n times (once in the example in the figure) for the same table (Persons). From the design information, as shown on the right side of the figure, test data for branch (C1) and successful INSERT is generated. For example, in order for the update access INSERT to succeed, it is necessary that the same value as newID does not exist in the ID column in the DB initial state. Since an error occurs due to the duplication of the primary key in the record to be updated, in the present invention, in order to avoid this, update access is performed on the condition that it is guaranteed that the record to be updated does not have the same primary key value. The query to a reference access query.

  FIG. 3 shows a configuration of the test data generation apparatus according to the embodiment of the present invention.

Test data generating apparatus 1 shown in FIG. 1, test case extraction unit 10, the update system query conversion unit 20, the test case grouping unit 30, the input variable constraint expression generation unit 40, the record allocation determination unit 50, DB table variable constraint The generating unit 60, the constraint equation solving unit 70, the test data output unit 80, the test case storage unit 15, the test case group set storage unit 35, and the record arrangement table memory 55 are configured. The test case storage unit 15, the test case group set storage unit 35, and the record arrangement table memory 55 are storage media such as a hard disk and a memory. In addition, the record arrangement table memory 55 is provided outside the record arrangement determining unit 50, but is not limited to this example, and may be provided in the record arrangement determining unit 50.

  First, data input from the terminal 2 to the test data generation device 1 will be described.

  4 to 6 show examples of design information of the present invention.

  FIG. 4 is an example of a DB definition input according to the embodiment of the present invention.

  DB definition (Persons table) is DB table ID, DB record column, column ID (String type and domain, column type (Normal / Primary Key)), type and domain, integer domain, column type, etc. Is defined.

  FIG. 5 is an example of a test case (path) that is input in one embodiment of the present invention. The processing flow diagram shown in Fig. 6A consists of a node indicating the processing content and an edge indicating the transition from one processing to the next, and includes a node ID, node content, query Id, query (SELECT, UPDATE, INSERT , DELETE), column and setting value, WHERE clause condition group, next node connection edge group, edge ID, guard condition, integer constraint, integer arithmetic expression, integer term, integer comparison operator, integer factor, column reference, variable reference, etc. Is stipulated. Note that the SELECT query includes ResultRecordCount.

  The SELECT query has From TableId, Where clause condition group, and Result Count.

  The UPDATE query has TableId, a column and a set value + Where clause condition group.

  The INSERT query has Into TableId, column, and setting value.

  The DELETE query has a From TableId and a Where clause condition group.

  FIG. 6 is an example of an input value definition to be input in an embodiment of the present invention.

  An input value definition includes an input value, a String type and a domain of the input value.

  Processing in the above configuration will be described.

  FIG. 7 is a flowchart of an outline operation of the test data generation apparatus according to the embodiment of the present invention.

  Step 110) The test case extraction unit 10 extracts a test case from the design information (XML format) input from the terminal 2, and stores it in the test case storage unit 15. Detailed operation will be described in detail with reference to FIG.

  Step 120) The update query conversion unit 20 acquires a test case from the test case storage unit 15, and converts the update query in the test path into a reference query so as to satisfy the conditions of the update query. Detailed operation will be described in detail with reference to FIG.

  Step 130) The test case grouping unit 30 reads the test cases extracted in step 110 from the test case storage unit 15, groups the test cases that reuse the same DB initial state as test case groups, and sets the test case group storage unit. 35. As shown in FIG. 8, the test case group set storage unit 35 stores test cases acquired from the test case storage unit 15 for each test case group ID (test case + constraint set, DB table variable). The test case includes test case Id, FlowId, (test path, converted update query), constraint set, DB table variable, DB field variable, reference group query (SELECT query), input variable, and integer type variable.

  In the present embodiment, it is assumed that the reference query (SELECT) is grouped based on a parameter input by the user for grouping the reference query. In addition, with respect to the converted update query, one test case group is assigned to one test case. Detailed operation will be described in detail with reference to FIG.

  Step 140) The input variable constraint expression generation unit 40 acquires a test case group from the test case group set storage unit 35, extracts test cases included in the test case group, and generates a constraint expression for input variables in the test case. And added to the constraint set for each test case group in the test case group set storage unit 35. This process is repeated for all the test cases that have been acquired. Detailed processing will be described in detail with reference to FIG.

Step 150) The record arrangement determining unit 50 reads the test case group from the test case group set storage unit 35, and extracts the DB table variable of the test case included in the test case group. Based on the DB table variable, the number of records in the DB table to be finally generated and the position where the record that hits each reference query is arranged are determined. The number of records is the total number of search result records (ResultRecordCount) for each DB table query (SELECT), and the process of adding a SELECT query to the DB table variable reference query group is repeated for the number of records, and the test case group This is added to the reference query group of DB record variables in the set storage unit 35. Detailed processing will be described in detail with reference to FIG.

  Step 160) The DB table variable constraint expression generation unit 60 reads the test case group from the test case group set storage unit 35, refers to the record arrangement table, and relates to each DB field variable of the test case included in the test case group. A constraint equation is generated and added to the constraint set of the test case group in the test case group set storage unit 34. In addition, a constraint expression related to the input variable of each test case is also generated and added to the constraint set in the same manner. Detailed processing will be described in detail with reference to FIG.

  Step 170) The constraint equation solving unit 70 reads the constraint set of the test case group in the test case group set storage unit 35, extracts the constraint equation, solves the simultaneous inequality, obtains one solution at random, and obtains the test case group. Store in the collective storage unit 35. To solve the simultaneous inequality, an existing constraint solver (Trends in constraint Programming (Frederic Benhamou et. Al., Wiley-ISTE, 1905209975, 2007)) is used.

  Step 180) The test data output unit 80 uses the input value for each test case acquired from the test case group set storage unit 35 and one DB initial state value to be used in the test case as test data used by this test case group. And output as For this processing, for example, the technique described in Patent Document 1: Japanese Patent Application Laid-Open No. 2010-267022 can be applied.

  The operation of each step in FIG. 7 will be described in detail below.

<Process of Test Case Extraction Unit (Step 110)>
Next, the process of the test case extraction unit 10 in step 110 of FIG. 7 will be described.

  FIG. 9 is a flowchart of detailed processing in S110 according to the embodiment of the present invention.

  Step 210) The test case extraction unit 10 extracts a test path from the processing flow diagram of the input design information. For example, in the example of FIG. 5, all test paths are extracted so as to satisfy the branch condition C1 coverage.

  Step 220) Next, a test case having the test path is created from the extracted test path and stored in the test case storage unit 15. As a test case creation method, Patent Document 1 (Patent No. 4966386) for extracting a test case corresponding to each path extracted from the processing flow diagram (one extracted path becomes one test case) Can be used.

  Step 230) Obtain the DB definition of the design information, extract the DB table variable, and add it in association with the test case in the test case storage unit 15. An example of adding a DB table variable to the test case storage unit 15 is shown in FIG.

  Step 240) The input value definition of the design information is read, input values (input variables and constraints) are extracted, added to the test cases in the test case storage unit 15 as shown in FIG. In the example of FIG. 6, the type, minimum value, and maximum value corresponding to the input value name are extracted and added as input variables in FIG. 10 in association with the test case.

<Processing of Update Query Update Unit (Step 120)>
Next, the processing of the update query update unit 20 in step 120 of FIG. 7 will be described.

  FIG. 11 is a flowchart of detailed processing of the update query update unit according to the embodiment of the present invention.

  Step 310) A test case is read from the test case storage unit 15.

  Step 320) In the test pass of the test case, get the query that exists at the end. If the acquired query is a reference query (SELECT), the following processing is not performed and the processing proceeds to step 130. If the acquired query is an update query, the following processing is performed.

Step 330) If the query type is an INSERT query, a reference query is generated on condition that the uniqueness after the record is inserted is a condition. Here, guaranteeing uniqueness after insertion refers to ensuring that unique keys do not overlap after updating. Specifically, the Into TableId from the INSERT query and the columnId and setValue are extracted from the “column and set value” where the column is the primary key, and copied to be copiedInto Tabled, copied ColumnId, and copiedSetValue. Using these, `` SELECT * FROM copiedInto TableId WHERE copiedColumnId = copiedSetValue, ResultCount = 0 ''
A new SELECT query is created, which is used as a converted update query, and the process proceeds to step 370.

Step 340) If the query type is an UPDATE query, a reference query is generated on condition that the existence of the record to be updated is guaranteed. Specifically, the TableId and WHERE clause condition groups are extracted from the UPDATE query and copied to obtain the copiedTableId and copiedWhere clause condition groups. Using them,
"SELECT * FROM copiedTableId WHERE copiedWhere clause condition group"
Create a new SELECT query, and use this as the converted update query.

Step 350) Further, a reference query is generated on the condition that the uniqueness guarantee after the record is updated. Specifically, from the UPDATE query, ColumnId and SetValue are extracted from TableId and the column and set value whose column is the primary key, and copiedTableId, copiedColumnId, and copiedSetValue. Using them,
“SELECT * FROM copiedInto TableId WHERE copiedClumnId = copiedSetValue, ResultCount = 0”
Create a new SELECT query, and use this as the converted update query.

Step 360) If the query type is a DELET query, a reference query is generated on condition that the existence of the record to be deleted is guaranteed. Specifically, the TableId and Where clause condition group is extracted from the DELETE query and copied to obtain the copiedTableId and copiedWhere clause condition group. Using them,
`` SELECT * FROM copied TAbleId WHERE copiedWhere clause condition group ''
Create a new SELECT query, and use this as the converted update query.

  Step 370) The reference query newly created in each of the above steps 330, 340, 350, 360 is added as a converted update query to the test case converted update query in the test case group set storage unit 35. Note that when the process proceeds from step 340, two converted update queries are input.

  FIG. 12 shows an example of conversion from the above update query to a reference query.

  The INSERT query is converted into a SELECT query as shown in (A) of the figure. In the case of conversion, an error occurs if the primary key is duplicated, so it is a condition that it is guaranteed that a record having the same primary key value as the record to be inserted does not exist in the DB initial state.

  The UPDATE query is converted into a SELECT query as shown in FIG. In the case of conversion, the condition is that there is one record to be updated. DB update is always performed by setting this condition. In addition, if the primary key is duplicated, an error occurs. Therefore, it is a condition that a record having the same key value as the updated record does not exist in the DB initial state. This ensures that the DB is updated.

  The DELETE query is converted into a SLELECT query as shown in FIG. In the case of conversion, DB update is always performed on condition that there is one record to be deleted.

<Processing of test case grouping unit (step 130)>
Next, the process of the test case grouping unit 30 in step 130 in FIG. 7 will be described. In this process, the test cases that use the DB initial state are grouped and stored in the test case group set storage unit 35.

  FIG. 13 is a flowchart of detailed processing of the test case grouping unit according to the embodiment of the present invention. FIG. 14 shows an operation example of the test case grouping unit in the embodiment of the present invention. In the example of FIG. 14, test cases are grouped based on grouping parameters input from the user.

  Step 610) The test case grouping unit 30 reads a test case set from the test case storage unit 15.

  Step 620) An empty test case group set is generated on the test case group set storage unit 35.

  Step 630) An empty reference query test case set is generated in the test case group set storage unit 35.

  Step 640) An empty update query test case set is created in the test case group set storage unit 35.

  Step 650) In step 610, the reference system test case read from the test case storage unit 15 is added to the reference query test case set in the test case group set storage unit 35.

  Step 655) The test case of the update query is added to the update query test case set in the test case group set storage unit 35.

  Step 657) After the processes of Steps 650 and 655 are repeated for all test cases in the test case set, grouping parameters for collecting reference query test cases are acquired from the user.

  Step 660) Group the test cases of the reference query test case set based on the grouping parameters. In the example of FIG. 14, {[01,02,03], [04,05]} is input as the grouping parameter. TestCase Id = 01, TestCase Id = 02, TestCase Id = 03 in the reference query test case set are grouped into TestCaseGroup01 as shown in the figure (a), and TestCase Id = 04 and TestCase Id = 05 are shown in the figure ( As shown in b), it is grouped into TestCaseGroup02.

  Step 670) The update query test case set obtained in Step 655 is acquired, and one test case is collected as one test case group and added to the test case group set in the test case group set storage unit 35. In the example of FIG. 14, as shown in (c) and (d), only “TestCase Id = 06” is added to the test case group 03, and only “TestCase Id = 07” is added to the test case group 04. Is added.

  Step 680) An arbitrary test case belonging to the test group is selected. The DB table variable group is the same regardless of which test case is selected.

  Step 690) The DB table variable of the selected test case is duplicated, substituted into the DB table variable of the test case group, and added to the test case in the test case group set storage unit 35.

  In the present invention, as described above, by creating a DB initial state that can be used by grouped test cases by grouping a plurality of test cases, one DB initial state is generated for one test case. The number of replacements of the DB initial state is less than that of the prior art.

<Processing of Input Variable Constraint Expression Generation Unit (Step 140)>
Next, the processing of the input variable constraint expression generation unit 40 in step 140 of FIG. 7 will be described.

  FIG. 15 is a flowchart of detailed processing of the input variable constraint expression generation unit in one embodiment of the present invention.

  Step 810) The input variable constraint expression generation unit 40 reads the test case group from the test case group set storage unit 35.

  Step 820) Extract test cases from the test case group.

  Step 830) For all the input variables of the extracted test cases, a constraint expression is generated from the domain of the input variables. Specifically, let X be the input variable that was input. Get the minimum value (Min Value) and maximum value (Max Value) of the “integer domain” of the input value definition corresponding to the input variable X, and generate a new constraint expression of X ≧ Min Value, X ≦ Max Value The process of adding to the constraint set in the test case group set storage unit 35 in association with the test group is repeated for each input variable.

  Step 840) The guard condition included in the processing flow diagram (see FIG. 5) and the test case group acquired from the test group set storage unit 35 are input, and the integer constraint of the guard condition is set as the test of the test case group set storage unit 35. Add to the case group constraint set.

<Processing of Record Placement Determination Unit (Step 150)>
Next, the process of the record arrangement determining unit 50 in step 150 of FIG. 7 will be described.

  This process creates a record arrangement table by associating a DB table with a query.

  FIG. 16 is a flowchart of the detailed processing of the record arrangement determining unit in one embodiment of the present invention.

  Step 910) The record arrangement determining unit 50 reads the test case group from the test group set storage unit 35.

  Step 920) The DB table variable of the DB definition of the test case included in the test case group is read from the test case storage unit 15.

  Step 930) When the “FROM Table ID” of the SELECT query matches the ID of the DB table variable, the DB table is stored in the table of the record arrangement table memory 55 (table variable = “Table A” in the example of FIG. 17). Add SELECT query to variable reference query group.

  This process is repeated for each SELECT query of test cases belonging to the test case group.

  Step 940) The search result record count (ResultRecordCount) of each query Q1, Q2,..., Qn, Qi in the DB variable reference query group is set to Ri. The number of DB records R is R1 + R2 + ... + Rn, and R DB record variables are generated and added to the DB table variables. The number of search result records corresponds to “ResultRecordCount” held by the SELECT query in the processing flow diagram of FIG.

  Step 950) A record position counter is generated on the record arrangement table memory 55 and initialized with zero.

  Step 960) The SELECT query is registered in the record position counter of the DB table variable of the record arrangement table in the record arrangement table memory 55, and the record position counter is incremented by one.

  Specifically, a SELECT query is added to the reference query group of the DB record variable “record position counter” of the DB table variable, and then the record position counter is incremented by one.

  The above operation will be described with reference to FIG. The queries of Q1 to Q3 are SELECT queries (including the SELECT query converted from the update query in step 120), these SELECT queries refer to the DB table variable “TableA”, and the number of search result records is the query Since Q1 is 1, query Q2 is 2, and query Q3 is 3, 1 + 2 + 3 = 6 records are created on the record arrangement table.

  When the processing corresponding to the number of search result records of the SELECT query is completed, the DB table variable (SELECT query) of the record arrangement table is output to the test case group set storage unit 35.

  In the above description, the record arrangement table of the record arrangement table memory 55 is used. However, it is possible to directly set the reference query group included in each record variable of the DB table variable of the test case group set storage unit 35. For example, when there are Record1 and Record2 as DB record variables, when setting queries Q1 and Q2, query Q1 can be set for Record1, and queries Q1 and Q2 can be set for Record2.

<Processing DB table variable constraint generator (step 160)>
Next, a description is given of processing of the DB table variable constraint generator 60 in step 160 of FIG. This processing is processing for generating records that meet the conditions of the WHERE clause for records to be referenced, and generating records so that the records that are not referred to do not match the conditions of the WHERE clause.

Figure 18 is a flowchart of detailed processing of the DB table variable constraint generator according to an embodiment of the present invention.

Step 1010) DB table variable constraint expression generating unit 60 reads a test group from the test case groups set storage unit 35.

  Step 1020) Extract DB table variables of test cases included in the test group.

  Step 1030) Duplicate the WHERE clause condition group of each SELECT query in the DB table variable reference query group.

  Step 1040) Each column reference included in the WHERE clause condition group duplicated in Step 1030 is replaced with the DB field variable of the DB record variable corresponding to the column reference.

  Step 1050) If the SELECT query is included in the reference query group of the DB record variable, in order to create a logical negation of the duplicate query condition group, “duplicate WHERE clause condition group” is set to “NOT (duplicate WHERE clause condition group)”. Into a new replication query condition group. If the SELECT query is not included in the reference query group, this process is skipped.

  Step 1060) The duplicate WHERE clause condition group is added to the test case group constraint set in the test case group set storage unit 35.

  Step 1070) In the DB table variable of the test case, DB field variables whose corresponding column type is Primary Key are F1, F2,..., Fn (n is the number of DB record variables). A constraint expression for guaranteeing the uniqueness of Fi such as “F1 <F2 <... Fn” is generated and added to the constraint set of the test case group set storage unit 35.

The following describes the processing of the DB table variable constraint generator 60 with reference to FIG. 19.

DB table variable constraint generator 60 generates a constraint equation from the reference query for each table. The DB record variable represented by the Persons table in FIG. 19A and the image of the record arrangement table in FIG. 19B is acquired, and the number of search result records specified for the reference query (SELECT) in the Persons table Minute constraint expressions are generated and stored in the test case group set storage unit 35. In the example of the figure, for “SELECT * FROM Persons WHERE Id <10”, “not (Age [3].> = 10)” is set as the constraint expression for “AGE”.

A record arrangement determination unit 50 described above, by DB table variable constraint generator 60, the SELECT each sentence, for the record to which it references, generating a record that meets the conditions of the WHERE clause, refer to not record WHERE clause A record is generated as a NOT WHERE clause so that it does not match the above conditions. This makes it possible to generate test data for testing a test case that executes the subsequent SELECT statement according to the number of records of the reference result of the immediately preceding SELECT statement. In addition, each reference access on the test path is guaranteed to return the expected number of records without excess or deficiency. As a result, it is possible to generate an initial DB state that constitutes test data for testing a test case (test path) that executes the subsequent SELECT statement according to the number of records of the reference result of the immediately preceding SELECT statement.

  The constraint equation solving unit 70 reads a constraint equation from the test case set storage unit 35, applies a constraint solver to the constraint equation, obtains a test case solution, and obtains each table variable of the test case group set storage unit 35. Add to each DB field variable of each DB record.

  The test data output unit 80 reads the test case and test data from the test case group set storage unit 35 and outputs the test case group and test path in text format. As shown in FIG. 18, the test case group includes test group group data, test group Id, DB table variable, test case (Id, flow Id, test path), DB table variable (Id, DB record variable), Includes DB record variables (Id, index, DB field variables), DB field variables (Id, integer type variable input), variables (Id, integer type variable), integer type variables (variable value).

  The operation of the constituent elements of the test data generation apparatus shown in FIG. 3 can be constructed as a program, installed on a computer used as the test data generation apparatus, executed, or distributed via a network. It is.

  The present invention is not limited to the above-described embodiments, and various modifications and applications are possible within the scope of the claims.

DESCRIPTION OF SYMBOLS 1 Test data generation apparatus 2 User terminal 10 Test case extraction part 15 Test case storage part 20 Update system query update part 30 Test case grouping part 35 Test case group set storage part 40 Input variable constraint expression generation part 50 Record arrangement | positioning determination part 55 Record arrangement table memory 60 DB table variable constraint generator 70 constraint equation solver 80 test data output unit

Claims (9)

A data generation device for a test having update access in a test path for generating test data having update access in addition to reference access during a test path for a database (DB),
A test case extraction means for extracting a test case from the inputted design information and storing it in the test case storage means;
When the test case is read from the test case storage unit and the last query type in the test path is an update query, the update query is converted into a reference query based on a condition according to the query type, Update query conversion means for storing in the test case storage means;
The test cases are read from the test case storage means, and test cases that can share the same initial DB state are grouped as test case groups so that there is no duplication in the records extracted by each SELECT statement of test cases belonging to the same group. , Test case grouping means for storing in the test case group set storage means,
Reading the test case group from the test case group set storage means, obtaining information of each test case of the test case group from the test case storage means, generating a constraint equation of the input variables of the test case, An input variable constraint expression generating means for storing in a constraint set of a test case group set storage means including a test case;
Obtain the test case group from the test case group set storage means, extract the DB table variable of the test case included in the test case group, determine the number of records of the DB table variable, and refer to the DB table variable A process for adding a SELECT query to a query group is repeated for the total number of search result records of each query, and a record arrangement determining unit that is added to a reference query group of DB table variables of the test case group set storage unit;
Said generating the constraint equation relating DB field variable test cases included in the test case groups, DB variable constraint expression generating means for adding the constraint set of the test case groups set storage unit of the test case group set storage unit,
Constraint equation solving means that solves the constraint expression stored in the test case group set storage means using an arbitrary solution and outputs the input value for each test case and the DB initial state sharing the test case as test data When,
A test data generation device having update access during a test path. The update query conversion means includes:
When the update query is an INSERT query, means for generating a SELECT query that guarantees uniqueness after inserting a record;
When the update query is an UPDATE query, means for generating a SELECT query that guarantees the presence of the update target record and does not cause duplicate unique keys after the update;
If the update query is a DELETE query, means for generating a SELECT query that guarantees the existence of the deletion target;
A test data generation apparatus having update access during a test path according to claim 1. The test case grouping means includes:
When the test case to be grouped includes an update query, a method for adding the test case to the update query test case set, and when not including the update query to the reference query test case set,
The reference query test case set is grouped based on an input grouping parameter, and the updated query test case set is a test case group for one test case;
The update during a test path according to claim 1, further comprising means for arbitrarily selecting one test case from the test case group and substituting the DB table variable of the selected test case into the DB table variable of the test case group. Data generator for testing with access. The DB variable constraint expression generating means,
With reference to records arrangement table records arrangement table storage means, wherein the generating a record that meets the conditions of the WHERE clause SELECT statement references the DB record variable, refers to not record the record so as not to coincide with the condition in the WHERE clause 2. The test data generation apparatus having update access during a test path according to claim 1, further comprising means for generating A data generation method for a test having update access in a test path for generating test data having update access in addition to reference access during a test path for a database (DB),
Test case storage unit, the test case group set storage unit, the test case extraction means, updated based query transformation means, test case grouping means, the input variable constraint expression generation unit, the record arrangement determining means, DB variable constraint generator, constraint equation In an apparatus having a solution means,
The test case extraction means extracts a test case from the inputted design information and stores it in the test case storage means;
When the update query conversion means reads the test case from the test case storage means and the type of the query that appears last in the test path is an update query, the update query conversion means updates the update based on a condition corresponding to the type of the query. An update query conversion step of converting the query into a reference query and storing the query in the test case storage means;
The test case grouping unit reads the test case from the test case storage unit, and the test cases that can share the same DB initial state are not duplicated in the records extracted by the SELECT statements of the test cases belonging to the same group. A test case grouping step for grouping as test case groups and storing them in a test case group set storage means;
The input variable constraint expression generation means reads the test case group from the test case group set storage means, acquires information of each test case of the test case group from the test case storage means, and inputs the test case An input variable constraint expression generation step for generating a constraint expression for a variable and storing the constraint expression in a constraint set of a test case group set storage means including the test case;
The record arrangement determining means acquires the test case group from the test case group set storage means, extracts a DB table variable of the test case included in the test case group, and determines the number of records of the DB table variable. , The process of adding the SELECT query to the reference query group of the DB table variable is repeated for the total number of search result records of each query, and the record to be added to the reference query group of the DB table variable of the test case group set storage means A placement determination step;
The DB variable constraint expression generating means generates constraint equation relating DB field variable test cases included in the test case groups of the test case group set storage unit, added to the constraint set of the test case groups set storage unit and DB variables constraint expression generation step of,
The constraint equation solving means solves the constraint expression stored in the test case group set storage means using an arbitrary solution, and inputs test values for each test case and the DB initial state sharing the test case. A constraint solution step to output as
A test data generation method having update access during a test path. In the update query conversion step,
If the update query is an INSERT query, generating a SELECT query that guarantees uniqueness after inserting the record;
When the update query is an UPDATE query, a step of generating a SELECT query that guarantees the existence of an update target record and does not cause duplication of a unique key after update;
If the update query is a DELETE query, generating a SELECT query that guarantees the existence of the deletion target;
A test data generation method having update access during a test path according to claim 5. In the test case grouping step,
When an update query is included in the test cases to be grouped, the test case is added to the update query test case set. Otherwise, it is added to the reference query test case set.
The reference query test case set is grouped based on the input grouping parameters, and the update query test case set is set as one test case group for one test case,
6. The test path according to claim 5, wherein one test case is arbitrarily selected from the test case group, and the DB table variable of the selected test case is substituted for the DB table variable of the test case group. Data generation method for testing. In the DB variable constraint expression generation step,
With reference to records arrangement table records arrangement table storage means, wherein the generating a record that meets the conditions of the WHERE clause SELECT statement references the DB record variable, refers to not record the record so as not to coincide with the condition in the WHERE clause A test data generation method having update access during a test path according to claim 5. Computer
A test data generation program having update access during a test path for functioning as each unit of the data generation apparatus according to claim 1.

Images