CN112699022A - Real-time efficient automatic contract testing method and system - Google Patents
Real-time efficient automatic contract testing method and system Download PDFInfo
- Publication number
- CN112699022A CN112699022A CN202011543616.5A CN202011543616A CN112699022A CN 112699022 A CN112699022 A CN 112699022A CN 202011543616 A CN202011543616 A CN 202011543616A CN 112699022 A CN112699022 A CN 112699022A
- Authority
- CN
- China
- Prior art keywords
- test
- contract
- case
- test case
- verification
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 297
- 238000012795 verification Methods 0.000 claims abstract description 80
- 238000000034 method Methods 0.000 claims abstract description 31
- 230000004044 response Effects 0.000 claims description 43
- 238000012545 processing Methods 0.000 claims description 9
- 238000004458 analytical method Methods 0.000 claims description 6
- 238000010200 validation analysis Methods 0.000 claims 1
- 238000010586 diagram Methods 0.000 description 9
- 238000007726 management method Methods 0.000 description 9
- 230000006870 function Effects 0.000 description 7
- 230000008859 change Effects 0.000 description 6
- 238000012986 modification Methods 0.000 description 6
- 230000004048 modification Effects 0.000 description 6
- 230000008569 process Effects 0.000 description 6
- 238000010276 construction Methods 0.000 description 4
- 238000013524 data verification Methods 0.000 description 3
- 230000010354 integration Effects 0.000 description 3
- 230000008447 perception Effects 0.000 description 3
- 230000006872 improvement Effects 0.000 description 2
- 238000013441 quality evaluation Methods 0.000 description 2
- 238000012827 research and development Methods 0.000 description 2
- 238000007619 statistical method Methods 0.000 description 2
- 238000013461 design Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
- 238000012800 visualization Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3676—Test management for coverage analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3692—Test management for test results analysis
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Testing Of Engines (AREA)
Abstract
The invention discloses a real-time high-efficiency automatic contract testing method and a system, wherein the method comprises the following steps: the execution engine receives a test request containing a plurality of contract test case numbers, and reads a plurality of contract test cases corresponding to each contract test case number from a database according to the plurality of contract test case numbers in the test request; the execution engine sends the plurality of contract test cases corresponding to each read contract test case number to a case parser so that the case parser converts each contract test case into a test case executable by the unit test; and the execution engine receives the multiple unit test executable test cases sent by the case parser, and verifies each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case.
Description
Technical Field
The invention relates to the technical field of automatic testing, in particular to a real-time efficient automatic contract testing method and system.
Background
The consumer-driven contract test (CDC test) is a test of data formats between a consumer and a provider of a service, a current contract test framework is based on a contract document created by a consumer end, the service provider provides data in a corresponding format according to the created contract document and returns the data to the consumer, and whether the data provided by the service provider is matched with the contract generated by the consumer is judged through contract check.
The current contract testing framework has the following problems:
1. and the whole process management functions of contract use cases, use case execution, execution records and test reports are lacked.
2. The data format is single in verification, and the integrity, the accuracy, the return value format and the return value type of complex response information cannot be verified, so that the test coverage is low, and the accuracy rate of test data is low. The check rules with different formats need to be generated in an encoding mode, and flexibility is lacked.
3. The current contract testing framework has no real-time sensing function, and the influence of the modification of the micro-service interface on all other users can be found only by manually running the test.
4. The contract cases cannot be executed in batch, and the execution efficiency is low. The use case only supports manual trigger execution and cannot meet the requirement of automatic construction execution.
5. The contract testing framework lacks a graphical operation interface, has requirements on the coding capacity of testers, and the testing result is output by a console and cannot be stored persistently, so that the historical result cannot be inquired. The result output is not clear enough, the readability is poor, and the problem of quick positioning is not facilitated.
Disclosure of Invention
The invention provides a real-time high-efficiency automatic contract testing method and system, aiming at solving the problems that the existing testing tool has limited assertion type, cannot support the integrity of response information, a return value format and a check function of a return value type, has low efficiency and poor universality of an open source contract testing framework, is difficult to control the change of a micro-service interface, has huge verification cost after the change and the like.
The method for testing the real-time efficient automatic contract provided by the embodiment of the invention comprises the following steps:
the execution engine receives a test request containing a plurality of contract test case numbers, and reads a plurality of contract test cases corresponding to each contract test case number from a database according to the plurality of contract test case numbers in the test request;
the execution engine sends the plurality of contract test cases corresponding to each read contract test case number to a case parser so that the case parser converts each contract test case into a test case executable by the unit test;
and the execution engine receives the multiple unit test executable test cases sent by the case parser, and verifies each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case.
Preferably, the contract test case includes one or more test steps, and each test step includes a test step name, an interface request, a response header check, and a response body format check.
Preferably, before the executing engine receives the test request containing a plurality of contractual test case numbers, the executing engine further includes:
setting an execution trigger mode of the execution engine;
the triggering mode comprises a manual triggering mode and an automatic triggering mode.
Preferably, before the executing engine receives the test request containing a plurality of contractual test case numbers, the executing engine further includes:
configuring a check rule for the rule checker;
the verification rules comprise response head verification rules and response body verification rules.
Preferably, the executing engine performs verification processing on the test case executable by each unittest by calling a rule verifier, and obtaining a verification result of each contractual test case includes:
the execution engine carries out verification processing on the test case which can be executed by each unit test by calling a verification rule in a rule verifier to obtain a verification result, verification details and error information of each contract test case;
and the execution engine generates an analysis report of the test of each contract case according to the verification result, the verification details and the error information of each contract test case.
The system for testing the real-time efficient automatic contract provided by the embodiment of the invention comprises the following components:
the execution engine is used for receiving a test request containing a plurality of contract test case numbers and reading a plurality of contract test cases corresponding to each contract test case number from a database according to the plurality of contract test case numbers in the test request; sending a plurality of contract test cases corresponding to each read contract test case number to a case analyzer; receiving a plurality of unit test executable test cases sent by the case analyzer, and verifying each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case;
and the case parser is used for converting each contract test case into a test case which can be executed by the unit test.
Preferably, the contract test case includes one or more test steps, and each test step includes a test step name, an interface request, a response header check, and a response body format check.
Preferably, the execution engine is further configured to set an execution trigger mode of the execution engine;
the triggering mode comprises a manual triggering mode and an automatic triggering mode.
Preferably, the execution engine is further configured to configure a check rule for the rule checker;
the verification rules comprise response head verification rules and response body verification rules.
Preferably, the execution engine is specifically configured to perform verification processing on the test case executable by each unittest by calling a verification rule in the rule verifier to obtain a verification result, verification details and error information of each contract test case, and generate an analysis report of each contract case test according to the verification result, the verification details and the error information of each contract test case.
According to the scheme provided by the embodiment of the invention, web visualization full-stack management and control are realized. The contract use cases, the use case execution, the execution records and the test reports are managed in a unified and graphical mode, the usability of the tool is improved, the difficulty in writing contract tests is reduced, and the problem that the management function of an existing contract test framework is lost is solved. By modifying the Pattverify, flexible and rich interface data check rules are realized. The problem of checking the integrity of the complex response information, the format of the return value and the type of the return value is solved, and higher test coverage rate is realized. The integration with Jenkins enables the quick perception of the impact of service provider changes on service consumers. When one Service is called by a plurality of users at the same time, the influence of the modification of the Service on all other users is ensured to be quickly sensed, and the problem of violating the interface contract is timely found. And batch execution of the contract use cases is realized based on unittest, so that the execution efficiency is higher. Besides manual trigger operation, an unattended automatic operation mode is supported, manpower is liberated through automatic construction and testing, and working efficiency is improved. Providing rich and clear test reports. The test result can be conveniently obtained through test overview and test details, and the problem can be quickly positioned by developers and testers. The statistical analysis of the test results is supported, and the change trend of the test results is facilitated to be known through the summary statistics of the historical test results, so that the quality condition of the service interface is analyzed.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description serve to explain the invention without limiting the invention. In the drawings:
FIG. 1 is a flow chart of a method for real-time efficient automated contract testing according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of a system for real-time efficient automated contract testing according to an embodiment of the present invention;
FIG. 3 is a flow chart of the creation, testing and querying of an automated contract testing tool provided by an embodiment of the present invention;
FIG. 4 is a diagram of a use case execution logic architecture provided by an embodiment of the present invention;
FIG. 5 is a schematic illustration of a contract test report provided by an embodiment of the present invention;
FIG. 6 is a functional block diagram provided by an embodiment of the present invention;
FIG. 7 is a logic diagram for implementing the method for real-time efficient automated contract testing according to an embodiment of the present invention;
FIG. 8 is a schematic diagram of a use case set provided by an embodiment of the present invention;
FIG. 9 is a schematic diagram of a system for real-time efficient automated contract testing according to an embodiment of the present invention;
FIG. 10 is a diagram of an execution engine invoking a rule checker according to an embodiment of the present invention;
FIG. 11 is a schematic diagram of a test report provided by an embodiment of the present invention.
Detailed Description
The preferred embodiments of the present invention will be described in detail below with reference to the accompanying drawings, and it should be understood that the preferred embodiments described below are only for the purpose of illustrating and explaining the present invention, and are not to be construed as limiting the present invention.
Fig. 1 is a flowchart of a method for real-time efficient automated contract testing according to an embodiment of the present invention, as shown in fig. 1, including:
step S101: the execution engine receives a test request containing a plurality of contract test case numbers, and reads a plurality of contract test cases corresponding to each contract test case number from a database according to the plurality of contract test case numbers in the test request;
step S102: the execution engine sends the plurality of contract test cases corresponding to each read contract test case number to a case parser so that the case parser converts each contract test case into a test case executable by the unit test;
step S103: and the execution engine receives the multiple unit test executable test cases sent by the case parser, and verifies each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case.
Preferably, the contract test case includes one or more test steps, and each test step includes a test step name, an interface request, a response header check, and a response body format check.
Preferably, before the executing engine receives the test request containing a plurality of contractual test case numbers, the executing engine further includes: setting an execution trigger mode of the execution engine; the triggering mode comprises a manual triggering mode and an automatic triggering mode.
Preferably, before the executing engine receives the test request containing a plurality of contractual test case numbers, the executing engine further includes: configuring a check rule for the rule checker; the verification rules comprise response head verification rules and response body verification rules.
Preferably, the executing engine performs verification processing on the test case executable by each unittest by calling a rule verifier, and obtaining a verification result of each contractual test case includes: the execution engine carries out verification processing on the test case which can be executed by each unit test by calling a verification rule in a rule verifier to obtain a verification result, verification details and error information of each contract test case; and the execution engine generates an analysis report of the test of each contract case according to the verification result, the verification details and the error information of each contract test case.
Fig. 2 is a schematic diagram of a system for real-time efficient automated contract testing according to an embodiment of the present invention, as shown in fig. 2, including: the execution engine 201 is configured to receive a test request including a plurality of contract test case numbers, and read, from a database, a plurality of contract test cases corresponding to each contract test case number according to the plurality of contract test case numbers in the test request; sending a plurality of contract test cases corresponding to each read contract test case number to a case analyzer; receiving a plurality of unit test executable test cases sent by the case analyzer, and verifying each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case; the use case parser 202 is configured to convert each contract test case into a test case executable by unittest.
Preferably, the contract test case includes one or more test steps, and each test step includes a test step name, an interface request, a response header check, and a response body format check.
Preferably, the execution engine is further configured to set an execution trigger mode of the execution engine; the triggering mode comprises a manual triggering mode and an automatic triggering mode.
Preferably, the execution engine is further configured to configure a check rule for the rule checker; the verification rules comprise response head verification rules and response body verification rules.
Preferably, the execution engine is specifically configured to perform verification processing on the test case executable by each unittest by calling a verification rule in the rule verifier to obtain a verification result, verification details and error information of each contract test case, and generate an analysis report of each contract case test according to the verification result, the verification details and the error information of each contract test case.
The technical scheme of the invention is explained in detail in the following with the accompanying drawings
The invention establishes a contract test full-stack type control method. The traditional contract test case compiling, executing and managing mode is changed, the contract case, the executing mode and the test report which are independently developed are compiled and analyzed in a unified and customized mode, the complexity and the workload of contract test codes are reduced, the automatic test executing efficiency is improved, the test automation and the high efficiency under the micro-service are realized, and the problem of the function compiling complexity of an open-source contract test framework is solved.
The invention establishes a flexible and rich micro-service interface response data verification method. The method solves the problems of the integrity, the accuracy, the return value format and the return value type of the complex interface data of the micro service and the micro application, greatly enhances the coverage of the interface data test, and improves the verification efficiency of the accuracy of the interface data.
The invention establishes a contract test real-time perception method. When one Service is called by a plurality of users at the same time, the influence of the modification of the Service on all other users is ensured to be quickly sensed, and the problem of violating the interface contract is timely found.
The invention establishes an automatic contract test operation mode, supports batch execution of contract cases and has higher execution efficiency. Besides manual trigger operation, an unattended automatic operation mode is supported, manpower is liberated through automatic construction and testing, and working efficiency is improved.
The invention establishes a method for inquiring a test report. The test result can be conveniently obtained through test overview and test details, and the problem can be quickly positioned by developers and testers. The method solves the problems of poor readability of test reports and no history report storage in the conventional contract test framework. The method supports statistical analysis of the test results, and helps to know the variation trend of the test results through summarizing and counting the historical test results, so as to analyze the quality condition of the micro-service interface.
The invention establishes a real-time high-efficiency automatic contract testing method. The technical scheme mainly comprises the steps of establishing a web-form visual whole-process management method by carrying out unified graphical management on contract cases, case execution, execution records and test reports; in order to realize higher test coverage rate, a flexible and rich data verification rule realization method is established by integrating the Pactverify rule with the Pactverify rule; establishing a real-time quick perception method for the influence of service provider change on service consumers through integration with Jenkins; in order to realize batch execution of the use cases and improve the working efficiency, a contract test automatic operation mode is established; a method for inquiring test reports is established, and the problems that test results cannot be stored for a long time and historical results cannot be inquired are solved. The creating, testing and inquiring processes of the real-time efficient automatic contract testing method are shown in FIG. 3, 1) a case set and a contract case are created according to an interface description; 2) configuring a check rule; 3) setting a use case execution triggering mode; 4) analyzing the execution case; 5) generating an execution record and a result detail; 6) generating a contract test report; 7) and (6) summarizing and analyzing historical data.
Aiming at the aforementioned technical requirements and problems, the following technical schemes are respectively adopted for breakthrough and solution:
and establishing a case set and a contract case according to the interface description, and establishing a contract test full-stack type management and control method. And the tester logs in the system, enters the contract testing function module and creates a case set according to the interface module. Selecting a use case set to be added with the contract use case, and filling the content of the contract use case according to a service interface defined in the design stage. And the contract case is managed in a tree structure according to the actual system service and is stored in a database in a binary format. The content of the contract use case is in a json format, and the content comprises contract request information, response information and verification rule information.
The contract case content is as follows:
the specific parameters are as follows:
name is the case step Name;
the Request is Request information including a Request address, a Request mode, a Request header and the like; valid is response header authentication information;
contact is response body authentication information.
One contract use case can contain a plurality of interface contracts, and can be flexibly used according to specific scenes in the using process. If one microservice interface corresponds to a plurality of microservice consumers, a plurality of contract testing steps can be set in the same use case, as follows:
a flexible and rich micro-service interface response data verification method is established by configuring a response head and a response body verification rule. And verifying the response head and the response body by configuring a verification rule. The response header check rule is defined in the "valid" list, and the check rule is a comparison between an actual response header result and an expected result, and includes equal, less than or equal to, greater than or equal to, and unequal. The response experience certification rule is implemented based on pactverify and is defined in 'extract', the verification rule comprises value matching, type matching, array type matching, regular matching, enumeration matching and complex rule matching, and the verification of the integrity, the return value format and the return value type of the response information is realized through the abundant verification rules.
A contract test real-time sensing method is established, and a contract test automatic operation mode is established by setting a case execution triggering mode. And executing the contract use case through two modes of manual triggering and automatic triggering. Selecting a case set or a plurality of cases, and clicking 'execution' to perform manual triggering; and increasing contract test execution nodes through a Jenkins pipeline plug-in extension function, inquiring and acquiring a contract case set created in the project through a database in the contract test execution nodes, and checking the contract case to be executed. The configuration timing trigger task or the automatic trigger when the configuration source code library is changed, the contract test can be executed along with the operation of the jenkins production line, and the automatic continuous integration test is realized. Through frequent construction, packaging and testing of the assembly line, the problem of violating the interface contract is timely found, and the influence of the modification of the service on all other users is rapidly sensed.
And analyzing the execution contract use case. Reading the selected contract case from a database based on a unit test framework, analyzing the request, the parameters and the verification rule of each step in the contract case, generating a test case executable by the unit test, calling PactVerify to verify the contract rule, and finally realizing the automatic batch execution of the contract test. The use case execution logic architecture is shown in figure 4.
And generating an execution record and a result detail. And storing the execution details (request information and response information), the verification result (assertion information and error information) generated by the Pactverify, the execution time and the executor into a database after the use case is executed. The assertion information comprises an assertion result and assertion statistical information of each test step; the error information includes a use case execution error and an assertion error.
And generating a contract test report. As shown in fig. 5, the system generates a contract test report according to the test detail data generated by the background. The test report shows test overview information, test step details, verification results, details and error information. The test result can be conveniently obtained through test overview and test details, and the problem can be quickly positioned by developers and testers.
And summarizing and analyzing based on the historical test details of the database to generate test summarizing information of the project contracts, and displaying the overall results and the test result change trends of all the micro-service interface contracts under the projects. The quality evaluation and research and development process improvement of management personnel are facilitated.
The invention is described below with reference to fig. 6-11:
as shown in FIG. 7, the present invention mainly includes test cases, case parsers, execution engines, jenkins, rule checkers, execution details and results.
The use case management comprises a use case set and a contract use case. The case set is used for organizing and managing contract cases, and the test cases are classified according to the functional modules, the service scenes or the processes. The use case set comprises a plurality of independent contract use cases. As shown in fig. 6, each contract use case contains one or more test steps separated by commas. The test steps include test step name, interface request, response header check, and response style check, see fig. 8.
The use case execution comprises two modes of manual triggering and automatic execution. A user can select a test case to manually trigger the execution engine to execute the test through a browser interface, and can also trigger a timing task to automatically trigger the execution engine to execute the test through jenkins. The execution engine receives the incoming test case number set, reads case contents from the database according to the case numbers, analyzes the case contents through the case parser, and converts the case contents into a unittest test case for the execution engine to call and execute, which is shown in fig. 9.
The execution engine calls a rule checker (PactVerify module) to verify the check rule defined in the use case, and the check rule returns the check result, the check details and the error information, which is shown in fig. 10.
And after the use case is executed, the execution engine stores the use case execution detail, the execution result, the verification detail, the error information, the executor and the execution time into the database. And the system generates a contract test report according to the data information returned by the execution engine. See fig. 11 for report content.
Through summarizing and counting the historical test results in the database, the overall test result of the project and the change trend of the historical test result are generated, and quality evaluation and research and development process improvement of management personnel are facilitated.
Although the present invention has been described in detail hereinabove, the present invention is not limited thereto, and various modifications can be made by those skilled in the art in light of the principle of the present invention. Thus, modifications made in accordance with the principles of the present invention should be understood to fall within the scope of the present invention.
Claims (10)
1. A real-time efficient automated contract testing method is characterized by comprising the following steps:
the execution engine receives a test request containing a plurality of contract test case numbers, and reads a plurality of contract test cases corresponding to each contract test case number from a database according to the plurality of contract test case numbers in the test request;
the execution engine sends the plurality of contract test cases corresponding to each read contract test case number to a case parser so that the case parser converts each contract test case into a test case executable by the unit test;
and the execution engine receives the multiple unit test executable test cases sent by the case parser, and verifies each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case.
2. The method of claim 1, wherein the contract test case comprises one or more test steps, and wherein each test step comprises a test step name, an interface request, a response header check, and a response body format check.
3. The method of claim 1, wherein before the execution engine receives the test request comprising a plurality of contractual test case numbers, the method further comprises:
setting an execution trigger mode of the execution engine;
the triggering mode comprises a manual triggering mode and an automatic triggering mode.
4. The method of claim 1, wherein before the execution engine receives the test request comprising a plurality of contractual test case numbers, the method further comprises:
configuring a check rule for the rule checker;
the verification rules comprise response head verification rules and response body verification rules.
5. The method according to claim 4, wherein the executing engine performs verification processing on the test case executable by each unit test by calling a rule verifier, and obtaining a verification result of each contractual test case comprises:
the execution engine carries out verification processing on the test case which can be executed by each unit test by calling a verification rule in a rule verifier to obtain a verification result, verification details and error information of each contract test case;
and the execution engine generates an analysis report of the test of each contract case according to the verification result, the verification details and the error information of each contract test case.
6. A system for efficient, real-time, automated contract testing, comprising:
the execution engine is used for receiving a test request containing a plurality of contract test case numbers and reading a plurality of contract test cases corresponding to each contract test case number from a database according to the plurality of contract test case numbers in the test request; sending a plurality of contract test cases corresponding to each read contract test case number to a case analyzer; receiving a plurality of unit test executable test cases sent by the case analyzer, and verifying each unit test executable test case by calling a rule verifier to obtain a verification result of each contract test case;
and the case parser is used for converting each contract test case into a test case which can be executed by the unit test.
7. The system of claim 6, wherein the contract test case comprises one or more test steps, and wherein each test step comprises a test step name, an interface request, a response header check, and a response body format check.
8. The system of claim 6, wherein the execution engine is further configured to set an execution trigger of the execution engine;
the triggering mode comprises a manual triggering mode and an automatic triggering mode.
9. The system of claim 6, wherein the execution engine is further configured to configure a validation rule for the rule verifier;
the verification rules comprise response head verification rules and response body verification rules.
10. The system according to claim 9, wherein the execution engine is specifically configured to perform verification processing on the test case executable by each unittest by calling a verification rule in a rule verifier to obtain a verification result, verification details, and error information of each contract test case, and generate an analysis report of each contract case test according to the verification result, the verification details, and the error information of each contract test case.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011543616.5A CN112699022A (en) | 2020-12-24 | 2020-12-24 | Real-time efficient automatic contract testing method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011543616.5A CN112699022A (en) | 2020-12-24 | 2020-12-24 | Real-time efficient automatic contract testing method and system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112699022A true CN112699022A (en) | 2021-04-23 |
Family
ID=75509582
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011543616.5A Pending CN112699022A (en) | 2020-12-24 | 2020-12-24 | Real-time efficient automatic contract testing method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112699022A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116166568A (en) * | 2023-04-25 | 2023-05-26 | 安元科技股份有限公司 | Method and system for automatically checking interface contract applied to functional test |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090006897A1 (en) * | 2007-06-27 | 2009-01-01 | Microsoft Corporation | Automated service testing |
| CN106095673A (en) * | 2016-06-07 | 2016-11-09 | 深圳市泰久信息系统股份有限公司 | Automated testing method based on WEB interface and system |
| CN110990262A (en) * | 2019-11-08 | 2020-04-10 | 安徽继远检验检测技术有限公司 | Test method and tool integration based on micro-service architecture |
| CN111176660A (en) * | 2019-12-31 | 2020-05-19 | 中信百信银行股份有限公司 | Distributed architecture-oriented micro-service contract management method and device, computer equipment and readable storage medium |
-
2020
- 2020-12-24 CN CN202011543616.5A patent/CN112699022A/en active Pending
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090006897A1 (en) * | 2007-06-27 | 2009-01-01 | Microsoft Corporation | Automated service testing |
| CN106095673A (en) * | 2016-06-07 | 2016-11-09 | 深圳市泰久信息系统股份有限公司 | Automated testing method based on WEB interface and system |
| CN110990262A (en) * | 2019-11-08 | 2020-04-10 | 安徽继远检验检测技术有限公司 | Test method and tool integration based on micro-service architecture |
| CN111176660A (en) * | 2019-12-31 | 2020-05-19 | 中信百信银行股份有限公司 | Distributed architecture-oriented micro-service contract management method and device, computer equipment and readable storage medium |
Non-Patent Citations (2)
| Title |
|---|
| 何丹丹;王立娟;刘瑞杰;: "基于用例契约化的测试用例生成策略", 西南师范大学学报(自然科学版), no. 11, 20 November 2013 (2013-11-20) * |
| 李吟;: "基于接口契约的有状态Web服务用例集生成", 计算机研究与发展, no. 03, 15 March 2017 (2017-03-15) * |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116166568A (en) * | 2023-04-25 | 2023-05-26 | 安元科技股份有限公司 | Method and system for automatically checking interface contract applied to functional test |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109189684B (en) | Python-based automatic interface testing method | |
| CN102831052B (en) | Test exemple automation generating apparatus and method | |
| CN101930400B (en) | SDK (Software Development Kit) automatic test system and method | |
| CN106777101B (en) | Data processing engine | |
| CN111459821B (en) | Software automation unit test method based on TestNG | |
| US20060041539A1 (en) | Method and apparatus for organizing, visualizing and using measured or modeled system statistics | |
| CN103150249A (en) | Automatic testing method and system | |
| CN108628748B (en) | Automatic test management method and automatic test management system | |
| CN105068929A (en) | Test script generation method, test script generation device, testing method, testing device and testing system | |
| CN103164328A (en) | Method and device and system for regression testing of service function | |
| CN109522215A (en) | The automatic test platform of railway signal system safety-critical software | |
| CN114741283A (en) | Automatic interface testing method and device based on python design | |
| CN105760296A (en) | Automation testing control method, device and terminal | |
| CN109726830A (en) | Equipment routing inspection method, apparatus, electronic equipment and storage medium | |
| CN108460068A (en) | Method, apparatus, storage medium and the terminal that report imports and exports | |
| US20060059444A1 (en) | High level validation of designs and products | |
| CN112181854A (en) | Method, device, equipment and storage medium for generating flow automation script | |
| CN112306861A (en) | Unittest and Jenkins tool-based interface automatic testing system and method | |
| CN114880240A (en) | Automatic testing system and method for Internet of things equipment, storage medium and equipment | |
| CN114398293A (en) | Interface test case generation method, electronic device and storage medium | |
| CN112583663B (en) | Automatic network performance testing method based on domestic operating system | |
| CN112699022A (en) | Real-time efficient automatic contract testing method and system | |
| CN113448826A (en) | Software automation test system and method | |
| CN114460925A (en) | Automatic HIL (high-level intelligence) testing method for CAN (controller area network) interface of electric automobile controller | |
| CN117370217A (en) | Automatic interface test result generation method based on python |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |