Interface joint debugging data generation method, device and equipment and computer readable medium
Through the interface joint-tuning data generation method, users can generate interface joint-tuning data according to their own needs, solving the problem of difficulty in testing the reliability of local code in the prior art under wrong operations or abnormal situations, and realizing timely maintenance of local code.
Patent Information
- Application Number
- CN202411233959.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-09-04
- Publication Date
- 2024-12-06
- Estimated Expiration
- 2044-09-04
AI Technical Summary
The existing interface joint debugging test method is difficult to test the reliability of local code incorrect operation or abnormal situations, making it difficult for users to maintain local code in a timely manner.
Through the interface joint debugging data generation method, respond to the user's test case query information, retrieve the pre-generated interface test knowledge graph, generate the test case editing page, allow users to edit the test cases, and generate interface joint debugging data based on the edited information, providing User-defined test case identifier.
This enables users to generate data that meets the joint debugging test according to their own needs, which facilitates discovering and maintaining problems in local code, and improves the reliability testing capabilities of local code in case of error operations or exceptions.
Smart Images

Figure CN119088985A_ABST
Abstract
Description
Technical Field
[0001] Embodiments of the present disclosure relate to the field of computer technology, and in particular to a method, apparatus, device, and computer-readable medium for generating interface joint debugging data. Background Art
[0002] Before the data demand user connects to the data application interface through the local application to obtain the required data, the local application and the data application interface need to be jointly debugged and tested to ensure that the user end can normally obtain and successfully parse the interface response data. At present, when performing interface joint debugging tests, the method usually adopted is: the data application provider manually writes or automatically generates positive test case data, and sends the positive test case data to the user end, so that the user end can perform joint debugging tests on the local application and the data application interface based on the positive test case data.
[0003] However, in practice, it is found that when performing interface joint debugging tests in the above manner, the following technical problems often occur:
[0004] Since positive test case data can only be used to test the expected normal behavior or function of the user-side code, it is difficult for the user-side to test the reliability of the local code under erroneous operations or abnormal conditions, which makes it difficult for the user-side to maintain the local code in a timely manner.
[0005] The above information disclosed in this Background section is only for enhancement of understanding of the background of the present disclosure concept and therefore it may contain information that does not form the prior art that is already known to a person of ordinary skill in the art. Summary of the invention
[0006] The content of this disclosure is used to introduce concepts in a brief form, which will be described in detail in the detailed implementation section below. The content of this disclosure is not intended to identify the key features or essential features of the technical solution claimed for protection, nor is it intended to limit the scope of the technical solution claimed for protection.
[0007] Some embodiments of the present disclosure propose methods, devices, equipment, and computer-readable media for generating interface joint debugging data to solve one or more of the technical problems mentioned in the above background technology section.
[0008] In a first aspect, some embodiments of the present disclosure provide a method for generating interface joint debugging data, the method comprising: in response to receiving interface joint debugging test case query information corresponding to a target data application, retrieving a pre-generated interface test knowledge graph to obtain a test case query result, and sending the test case query result to a user end; in response to receiving an edit request for the test case query result, generating a test case editing page based on the edit request, and sending the test case editing page to the user end, wherein the test case editing page includes a test case filling form; in response to receiving the test case editing information, determining an expected response result corresponding to the test case editing information, and sending the expected response result to the user end for updating the test case filling form; in response to receiving the case confirmation information for the updated test case filling form, obtaining a current timestamp, and concatenating a preset custom case type identifier and the current timestamp to obtain a test case identifier; based on the test case identifier and the case confirmation information, generating interface joint debugging data.
[0009] In a second aspect, some embodiments of the present disclosure provide an interface joint debugging data generation device, the device comprising: a retrieval and sending unit, configured to, in response to receiving interface joint debugging test case query information corresponding to a target data application, retrieve a pre-generated interface test knowledge graph to obtain a test case query result, and send the test case query result to a user end; a first generating and sending unit, configured to, in response to receiving an edit request for the test case query result, generate a test case editing page based on the edit request, and send the test case editing page to the user end, wherein the test case editing page includes a test A use case filling form; a determination and sending unit, configured to determine the expected response result corresponding to the test case editing information in response to receiving the test case editing information, and send the expected response result to the user terminal for updating the test case filling form; an acquisition and splicing processing unit, configured to obtain the current timestamp in response to receiving the use case confirmation information for the updated test case filling form, and splice the preset custom use case type identifier and the current timestamp to obtain the test case identifier; a second generation unit, configured to generate interface joint debugging data based on the test case identifier and the use case confirmation information.
[0010] In a third aspect, some embodiments of the present disclosure provide an electronic device comprising: one or more processors; a storage device on which one or more programs are stored, and when the one or more programs are executed by the one or more processors, the one or more processors implement the method described in any implementation manner of the above-mentioned first aspect.
[0011] In a fourth aspect, some embodiments of the present disclosure provide a computer-readable medium having a computer program stored thereon, wherein when the computer program is executed by a processor, the method described in any implementation manner of the above-mentioned first aspect is implemented.
[0012] The above-mentioned embodiments of the present disclosure have the following beneficial effects: through the interface joint debugging data generation method of some embodiments of the present disclosure, the user can generate interface joint debugging data according to his own test requirements, so as to facilitate timely discovery of problems in the local code through joint debugging. Specifically, the reason why it is difficult for the user end to maintain the local code in a timely manner is that since the positive test case data can only be used to test the expected normal behavior or function of the user end code, it is difficult for the user end to test the reliability of the local code under erroneous operation or abnormal conditions, thereby causing the user end to be difficult to maintain the local code in a timely manner. Based on this, the interface joint debugging data generation method of some embodiments of the present disclosure, first, in response to receiving the interface joint debugging test case query information corresponding to the target data application, the pre-generated interface test knowledge graph is retrieved to obtain the test case query result, and the test case query result is sent to the user end. Thus, the information of the test case matching the user joint debugging test requirements can be obtained. Then, in response to receiving an edit request for the above test case query result, a test case editing page is generated based on the above edit request, and the above test case editing page is sent to the user end. Wherein, the above test case editing page includes a test case filling form. Thus, when the queried test case cannot meet the user's test requirements, a test case editing page can be provided for the user, so that the user can modify the queried test case according to his own needs to create a test case that meets the user's needs. Afterwards, in response to receiving the test case editing information, the expected response result corresponding to the above test case editing information is determined, and the above expected response result is sent to the above user terminal for updating the above test case filling form. Thus, the expected response data corresponding to the test case can be generated according to the information of the test case edited by the user. Then, in response to receiving the case confirmation information for the above updated test case filling form, the current timestamp is obtained, and the preset custom case type identifier and the above current timestamp are spliced to obtain the test case identifier. Thus, a unique test case identifier can be assigned to the test case created by the user. Finally, based on the above test case identifier and the above case confirmation information, interface joint debugging data is generated. Thus, the test data required by the user for joint debugging according to the self-created test case can be obtained. Therefore, the interface debugging data generation method of some embodiments of the present invention provides users with a test case editing page, so that when users need to test the reliability of local code under erroneous operations or abnormal conditions, they can easily generate interface debugging data that meets their own debugging test needs, thereby facilitating timely maintenance of local code on the user side. BRIEF DESCRIPTION OF THE DRAWINGS
[0013] The above and other features, advantages and aspects of the embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. Throughout the accompanying drawings, the same or similar reference numerals represent the same or similar elements. It should be understood that the drawings are schematic and that components and elements are not necessarily drawn to scale.
[0014] Figure 1 is a flow chart of some embodiments of the interface joint debugging data generation method according to the present disclosure;
[0015] Figure 2 It is a structural schematic diagram of some embodiments of the interface joint debugging data generating device according to the present disclosure;
[0016] Figure 3 It is a schematic diagram of the structure of an electronic device suitable for implementing some embodiments of the present disclosure. DETAILED DESCRIPTION
[0017] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as being limited to the embodiments set forth herein. On the contrary, these embodiments are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not intended to limit the scope of protection of the present disclosure.
[0018] It should also be noted that, for ease of description, only the parts related to the invention are shown in the drawings. In the absence of conflict, the embodiments and features in the embodiments of the present disclosure can be combined with each other.
[0019] It should be noted that the concepts such as "first" and "second" mentioned in the present disclosure are only used to distinguish different devices, modules or units, and are not used to limit the order or interdependence of the functions performed by these devices, modules or units.
[0020] It should be noted that the modifications of "one" and "plurality" mentioned in the present disclosure are illustrative rather than restrictive, and those skilled in the art should understand that unless otherwise clearly indicated in the context, it should be understood as "one or more".
[0021] The names of the messages or information exchanged between multiple devices in the embodiments of the present disclosure are only used for illustrative purposes and are not used to limit the scope of these messages or information.
[0022] The present disclosure will be described in detail below with reference to the accompanying drawings and in conjunction with embodiments.
[0023] Figure 1The process 100 of some embodiments of the interface joint debugging data generation method according to the present disclosure is shown. The interface joint debugging data generation method includes the following steps:
[0024] Step 101, in response to receiving interface joint debugging test case query information corresponding to the target data application, searching the pre-generated interface test knowledge graph to obtain the test case query result, and sending the test case query result to the user end.
[0025] In some embodiments, the execution subject (e.g., computing device) of the interface joint debugging data generation method may, in response to receiving the interface joint debugging test case query information corresponding to the target data application, retrieve the pre-generated interface test knowledge graph in various ways to obtain the test case query result, and send the test case query result to the user end. Among them, the target data application may be an application that provides demand data (e.g., personal credit score) to the user. The interface joint debugging test case query information may be information input by the user for querying the test case corresponding to the data application interface. The interface test knowledge graph may be a knowledge graph with data application, application interface, test case and application adapter subject type as entities, and with the corresponding relationship between data application and application adapter subject type, the corresponding relationship between data application and application interface, and the corresponding relationship between application interface and test case as the relationship between entities. The data application may be an application that provides data resources or services to data demanders through an application interface. The test case query result may be information of the retrieved test case identifier. The test case identifier may be a unique identifier of the test case. The application adapter subject type may be a personal type or an organizational type. The personal type may represent that the data application is applicable to providing the credit data of an individual. The organizational type may represent that the data application is applicable to providing the credit data of an organization. Each entity in the above interface test knowledge graph may have a corresponding entity identifier. The above entity identifier may be a unique identifier of the entity.
[0026] In some optional implementations of some embodiments, the interface joint debugging test case query information may include a data application identifier and a query text. The data application identifier may be a unique identifier of the data application. The query text may be text entered by the user in the search box. The execution subject may retrieve the pre-generated interface test knowledge graph through the following steps to obtain the test case query result:
[0027] The first step is to perform keyword extraction processing on the query text included in the above interface joint debugging test case query information to obtain a keyword result set. Among them, the above word segmentation result set can be subjected to keyword extraction processing by a preset keyword extraction processing method to obtain a keyword result set. For example, the above keyword extraction processing method can be an extraction method based on part of speech.
[0028] In the second step, for each keyword result in the above keyword result set, based on the above keyword result, the above interface test knowledge graph is searched to obtain a first search result. The above first search result may be the result of the test case obtained with the keyword result as the search term. For each keyword result, a fuzzy search may be performed on each entity information of the test case type in the above interface test knowledge graph through a fuzzy matching method to obtain the first search result. The entity information may include but is not limited to the entity identifier.
[0029] The third step is to search the interface test knowledge graph based on the data application identifier included in the interface joint debugging test case query information to obtain a second search result set. Among them, the second search result in the second search result set can be the result of the test case obtained by searching with the data application identifier included in the interface joint debugging test case query information as the search term. Through the full matching method, the various entities of the data application type in the interface test knowledge graph can be accurately searched according to the data application identifier included in the interface joint debugging test case query information, and the various test cases associated with the retrieved data application entities can be determined as the second search result set.
[0030] The fourth step is to generate a test case query result based on each of the first search results and the second search result set, wherein the intersection between each of the first search results and the second search result set can be determined as the test case query result.
[0031] Optionally, the above interface test knowledge graph can be pre-generated through the following steps:
[0032] The first step is to obtain an application interface relationship information set, an interface test case relationship information set and a data application information set. Among them, the interface test case relationship information in the above-mentioned interface test case relationship information set may include an interface identifier, a test case identifier and a test case type identifier. The above-mentioned interface identifier may be a unique identifier of the interface of the data application. The above-mentioned test case type identifier may be a unique identifier of the test case type. The above-mentioned test case type may be one of the following: a preset type, a custom type. The above-mentioned preset type may characterize that the corresponding test case is a pre-set non-user-created test case. The above-mentioned custom type may characterize that the corresponding test case is a user-created test case. The application interface relationship information in the above-mentioned application interface relationship information set includes a data application identifier and an interface identifier. The data application information in the above-mentioned data application information set includes a data application identifier and an adapter subject type identifier.
[0033] The second step is to determine each data application identifier in the above application interface relationship information set as a first entity identifier set.
[0034] The third step is to determine each interface identifier in the above application interface relationship information set as a second entity identifier set.
[0035] The fourth step is to determine each test case identifier in the above interface test case relationship information set as a third entity identifier set.
[0036] The fifth step is to determine each adapter subject type identifier in the above data application information set as a fourth entity identifier set.
[0037] Step 6: For each application interface relationship information in the application interface relationship information set, the first preset weight value, the data application identifier and the interface identifier included in the application interface relationship information are determined as the first entity relationship information. The first preset weight value can represent that the corresponding entity relationship is not affected by the user. For example, the first preset weight value can be 0.
[0038] In the seventh step, for each piece of data application information in the data application information set, the first preset weight value, the data application identifier and the adaptation subject type identifier included in the data application information are determined as the second entity relationship information.
[0039] Step 8: For each interface test case relationship information in the above interface test case relationship information set, perform the following steps:
[0040] In the first sub-step, in response to determining that the test case type identifier included in the above-mentioned interface test case relationship information satisfies the preset custom type condition, the second preset weight value, the interface identifier and the test case identifier included in the above-mentioned interface test case relationship information are determined as the third entity relationship information. Among them, the above-mentioned preset custom type condition can be that the test case type corresponding to the test case type identifier included in the interface test case relationship information is a custom type. The above-mentioned second preset weight value can represent that the corresponding entity relationship is affected by the user. For example, the above-mentioned second preset weight value can be 1.
[0041] The second sub-step, in response to determining that the test case type identifier included in the above-mentioned interface test case relationship information does not meet the above-mentioned preset custom type condition, determines the above-mentioned first preset weight value, the interface identifier and the test case identifier included in the above-mentioned interface test case relationship information as the fourth entity relationship information.
[0042] The ninth step is to generate an interface test knowledge graph based on the first entity identification set, the second entity identification set, the third entity identification set, the fourth entity identification set, the obtained first entity relationship information, the second entity relationship information, the third entity relationship information and the fourth entity relationship information. Among them, each entity corresponding to the first entity identification set, the second entity identification set, the third entity identification set and the fourth entity identification set can be used as a node, and the relationship between each entity corresponding to each first entity relationship information, each second entity relationship information, each third entity relationship information and each fourth entity relationship information can be used as an edge to construct an interface test knowledge graph.
[0043] It should be noted that in the above interface test knowledge graph, each entity is associated with other attributes in addition to the entity identifier. For example, when the entity is a data application, the entity's attributes may include but are not limited to the entity's name and entity's version number; when the entity is a data application interface, the entity's attributes may include but are not limited to the path; when the entity is a test case, the entity's attributes may include but are not limited to the title, input parameter (test input), and output parameter (expected output).
[0044] Step 102 , in response to receiving an edit request for a test case query result, generating a test case edit page based on the edit request, and sending the test case edit page to a user terminal.
[0045] In some embodiments, the execution subject may generate a test case editing page based on the editing request in response to receiving the test case query result, and send the test case editing page to the user end in various ways. The editing request may be a network request to obtain the test case details for editing. The editing request may include a test case identifier. The test case editing page may include a test case filling form. The test case filling form may be a form for creating a test case. The test case filling form may include various form item information. Each form item information may include a form item label and a form input element. The form item label may be a unique label for marking a form input element. For example, the form item label may be, but is not limited to, one of the following: a test case title, an interface identifier, an interface URL (Uniform Resource Locator), a test case input data, a test case output (response) data, and a verification code.
[0046] In some optional implementations of some embodiments, the execution entity may generate a test case editing page based on the editing request through the following steps:
[0047] The first step is to obtain the test case details information corresponding to the above-mentioned editing request. The above-mentioned test case details information may include an attribute information group. The attribute information in the above-mentioned attribute information group may include an attribute identifier and an attribute value. The above-mentioned attribute identifier may be a unique identifier of the attribute of the test case. The attributes of the test case may include but are not limited to a test case identifier, a test case title, an interface URL, a test case input data, and a creation timestamp. The test case details information including the test case identifier that is the same as the test case identifier in the above-mentioned editing request can be selected from a preset test case details information database. The above-mentioned test case details information database may be a database for storing test case details information.
[0048] In the second step, for each form input element included in the preset test case form template, perform the following steps to update the above form input element:
[0049] The first sub-step is to select the attribute information that matches the form input element from the attribute information group included in the test case details as the target attribute information, wherein matching the form input element may be that the attribute identifier included in the attribute information is the same as the form item label corresponding to the form input element.
[0050] The second sub-step is to determine the element value corresponding to the form input element based on the target attribute information, and to update the value attribute corresponding to the form input element. The element value may be the value corresponding to the value attribute of the form input element. The attribute value included in the target attribute information may be determined as the element value corresponding to the form input element, and the element value may be assigned to the value attribute corresponding to the form input element to update the value attribute.
[0051] The third sub-step is, in response to determining that the form input element satisfies a preset element condition, adding a read-only attribute to the form input element. The preset element condition may be that the form item label corresponding to the form input element is the form item label corresponding to the test case output data. The read-only attribute may indicate that the corresponding form input element can only be viewed by the user.
[0052] A fourth sub-step, in response to determining that the form input element does not satisfy the preset element condition, sets the content editable attribute corresponding to the form input element to true.
[0053] In addition, in the process of adopting technical solutions to solve the technical problems in the background technology part, considering that the creation of test cases is a sensitive operation, in order to reduce the risk of malicious attacks and improve data and system security, therefore, combined with the technical advantages of the solution development team in the field of deep learning, this disclosure decides to adopt the following steps:
[0054] The third step is to generate a verification code image to be identified in response to detecting that each form input element included in the test case form template has been updated. The verification code image to be identified may be an image including a verification code for a user to identify. The execution subject may generate a verification code image to be identified in various ways when detecting that all form input elements included in the test case form template have been updated.
[0055] Continuing, in the process of using the above steps to improve data and system security, the following technical problems are often accompanied: how to increase the difficulty of machine recognition of verification code images to resist malicious attacks. In response to the above technical problems, the conventional solution is generally: add disturbance information to the original verification code image to obtain a verification code image to be recognized. However, the conventional solution also has the following technical problems: if the method of adding disturbance information is too fixed, it is easy for the verification code image to be cracked, resulting in poor data security. If too much disturbance information is added, it is difficult for users to recognize, resulting in a poor user experience. Therefore, in the face of the problems existing in the above conventional solutions, the present disclosure decides to adopt the following solution:
[0056] In some optional implementations of some embodiments, the execution subject may generate a verification code image to be identified by following the steps below:
[0057] Step 1, obtain an image perturbation method information set, a verification code image to be perturbed, and a verification code character sequence. Among them, the image perturbation method information in the above-mentioned image perturbation method information set may include a perturbation method identifier. The above-mentioned perturbation method identifier may be a unique identifier of the image perturbation method. The above-mentioned image perturbation method may be a method for achieving the purpose of perturbing the image by modifying the pixels of the image. For example, the above-mentioned image perturbation method may be, but is not limited to, one of the following: an image perturbation method based on JSMA (Jacobian-based Saliency Map Attack, gradient-based adversarial attack), an image perturbation method based on FGSM (Fast Gradient Sign Method, fast gradient sign method). The above-mentioned verification code image to be perturbed may be an image including a verification code that is not perturbed by the image perturbation method. The above-mentioned verification code character sequence may be a sequence in which the characters in the verification code image to be perturbed are arranged in order from left to right. The image perturbation method information set, the verification code image to be perturbed, and the verification code character sequence may be obtained from a database.
[0058] Step 2: for each piece of image perturbation method information in the above image perturbation method information set, perform the following steps:
[0059] Sub-step 1, using the image initial perturbation module included in the pre-deployed perturbation verification code image generation model, based on the above-mentioned image perturbation method information, perturb the above-mentioned verification code image to be perturbed to obtain the initial perturbation verification code image. Among them, the above-mentioned perturbation verification code image generation model may also include an image feature extraction module and a character recognition module. The above-mentioned image initial perturbation module can be used to perturb the verification code image to be perturbed. The above-mentioned image feature extraction module can be used to extract the features of the verification code image to be perturbed. For example, the above-mentioned image feature extraction module can be composed of a convolutional neural network. The above-mentioned character recognition module can be used to recognize the characters in the verification code image to be perturbed. For example, the above-mentioned character recognition module can be composed of a bidirectional long short-term memory network.
[0060] Sub-step 2: input the initial perturbation image into the image feature extraction module to obtain a verification code image feature vector, wherein the verification code image feature vector may be a vector obtained after dimensionality reduction of a multi-channel feature map corresponding to the initial perturbation image.
[0061] Sub-step three: input the verification code image feature vector into the character recognition module to obtain a predicted verification code character sequence.
[0062] Sub-step 4: determining a loss value between the verification code character sequence and the predicted verification code character sequence. The loss value may represent the difference between the verification code character sequence and the predicted verification code character sequence. The loss value between the verification code character sequence and the predicted verification code character sequence may be determined by a CTC (Connectionist Temporal Classification) loss function.
[0063] Step three: select the maximum value from the determined loss values as the target loss value.
[0064] Step 4: Based on the target loss value, determine the interference image corresponding to the verification code image to be disturbed. The interference image may be an image used to interfere with the verification code image to be disturbed so that the interfered verification code image is not easily correctly recognized by the machine learning model. The interference image corresponding to the verification code image to be disturbed may be determined based on the target loss value by a gradient descent algorithm.
[0065] Step 5, the interference image and the verification code image to be disturbed are fused to obtain a disturbed verification code image. The disturbed verification code image may be the verification code image to be disturbed superimposed with the interference image. The interference image and the verification code image to be disturbed may be fused by a preset fusion processing method to obtain a disturbed verification code image. For example, the fusion processing method may include but is not limited to at least one of: pixel weighted average method and wavelet transform fusion method.
[0066] Step six, using the pre-deployed interference image optimization model, perform feature extraction processing on the verification code image to be disturbed to obtain the first underlying feature vector and the first global feature vector, and perform feature extraction processing on the perturbed verification code image to obtain the second underlying feature vector and the second global feature vector. Among them, the interference image optimization model may include an underlying feature extraction module and a global feature extraction module. The underlying feature extraction module may be used to extract the underlying features of the image. The global feature extraction module may be used to extract the global features of the image. Both the underlying feature extraction module and the global feature extraction module are composed of deep convolutional neural networks. For example, the underlying feature extraction module may be composed of a VGG (Visual Geometry Group) network. The global feature extraction module may be composed of a densely connected network.
[0067] Step seven, determine the first feature loss value corresponding to the first underlying feature vector and the second underlying feature vector. The first feature loss value can characterize the difference in underlying features between the verification code image to be disturbed and the verification code image to be disturbed. First, the similarity between the first underlying feature vector and the second underlying feature vector is determined by the cosine similarity method. Then, in response to determining that the similarity is less than or equal to a preset truncation threshold, the preset truncation threshold is determined as the first feature loss value. The preset truncation threshold is a preset lower limit value for constraining the similarity. In response to determining that the similarity is greater than the preset truncation threshold, the similarity is determined as the first feature loss value.
[0068] Step 8: Determine the second feature loss value corresponding to the first global feature vector and the second global feature vector. The second feature loss value can represent the difference in global features between the verification code image to be disturbed and the verification code image to be disturbed. The second feature loss value corresponding to the first global feature vector and the second global feature vector can be determined by a mean square error loss function.
[0069] Step nine, based on the first characteristic loss value and the second characteristic loss value, determine the optimized interference image corresponding to the perturbed verification code image. The optimized interference image may be an optimized interference image. First, the sum of the first characteristic loss value and the second characteristic loss value is determined as the total loss value. Then, based on the total loss value, the optimized interference image corresponding to the perturbed verification code image is determined by the gradient descent algorithm.
[0070] Step 10: fusing the verification code image to be disturbed and the optimized interference image to obtain the verification code image to be identified. The verification code image to be disturbed and the optimized interference image can be fused by the fusion processing method to obtain the verification code image to be identified.
[0071] As an inventive point of an embodiment of the present disclosure, the above-mentioned step of generating the verification code image to be identified solves the technical problem of "poor data security or poor user experience" in the above-mentioned conventional solution. The reason why the conventional solution has poor data security or poor user experience is that if the method of adding disturbance information is too fixed, it is easy to make the verification code image cracked, and if too much disturbance information is added, it is difficult for the user to identify. If this solution solves the above problems, it can achieve the effect of improving data security and user experience. In order to achieve this effect, when the disturbance is added to the original verification code image, first, for each image disturbance method, it is respectively executed: first act on the original verification code image, then for the initial disturbance verification code image after the action, the machine recognizes the verification code in the image, and determines the loss value between the recognized verification code and the known correct verification code. In this way, the confrontation ability of different image disturbance methods can be determined. Secondly, the maximum loss value is selected from each loss value for gradient back propagation. In this way, a disturbance image with good performance against machine recognition can be obtained. Then, the disturbance image and the original verification code image are fused. In this way, a disturbance verification code image with disturbance information can be obtained. Afterwards, the underlying features and global features of the original verification code image and the perturbed verification code image are determined. Then, the loss value on the underlying features between the original verification code image and the perturbed verification code image is determined by a loss function based on cosine similarity, and the loss value on the global features between the original verification code image and the perturbed verification code image is determined by a mean square error loss function. Thus, the underlying feature differences and global feature differences between the original verification code image and the perturbed verification code image can be determined. Finally, according to the underlying feature differences and global feature differences, gradient back propagation is performed on the perturbed verification code image to obtain an optimized interference image, and the optimized interference image and the original verification code image are fused to obtain the verification code image to be identified. Thus, the generated verification code image to be identified can not only reduce the risk of malicious attacks, but also ensure that users can effectively identify the verification code. Thus, data security can be improved, as well as user experience.
[0072] The fourth step is to bind the verification code image to be identified to the verification code image element included in the test case form template, and determine the updated test case form template as the test case filling form. The verification code image element can be an image control on a web page for filling in the verification code image to be identified. The image path attribute value of the verification code image element included in the test case form template can be set to the image path corresponding to the verification code image to be identified.
[0073] Step 5: Fill the test case filling form into the preset test case editing page template to obtain the test case editing page. The preset test case editing page template may be a pre-set web page template including form variables. The form variables may represent the test case filling form. The test case filling form may be rendered into the preset test case editing page template through a template engine to obtain the test case editing page.
[0074] Optionally, the user terminal can perform the following steps:
[0075] The first step is to determine the target form input element sequence in response to detecting a click operation on the response result generation button control included in the above-mentioned test case editing page. Among them, the above-mentioned response result generation button control can be a button control for submitting a form to generate an expected response result. Each target form input element in the above-mentioned target form input element sequence can be a form input element that does not meet the above-mentioned preset element condition. The target form input element sequence can be a sequence in which the target form input elements are arranged according to the arrangement order of the elements in the editing page. First, the form input elements that do not meet the above-mentioned preset element conditions can be selected from the various form input elements included in the above-mentioned test case editing page as target form input elements to obtain various target form input elements. Then, the various target form input elements are sorted to obtain a target form input element sequence.
[0076] In the second step, for each target form input element in the target form input element sequence, the element value and form item label corresponding to the target form input element are determined as input item information.
[0077] The third step is to determine the input item information sequence and the current timestamp as the test case editing information, and send the test case editing information.
[0078] Step 103, in response to receiving the test case editing information, determining the expected response result corresponding to the test case editing information, and sending the expected response result to the user end for updating the test case filling form.
[0079] In some embodiments, the execution subject may determine the expected response result corresponding to the test case editing information in various ways in response to receiving the test case editing information, and send the expected response result to the user terminal for updating the test case filling form. The expected response result may be the response result output by the data application according to the test case editing information.
[0080] In some optional implementations of some embodiments, the test case editing information may include an input element value sequence. Each input element value in the input element value sequence may be an element value of a form input element. And the execution subject may determine the expected response result corresponding to the test case editing information by the following steps:
[0081] The first step is to perform data cleaning on each input element value included in the input element value sequence in the test case editing information to obtain a target input element value sequence. The target input element value in the target input element value sequence may be an input element value after data cleaning. The preset data cleaning interface may be used to perform data cleaning on each input element value included in the input element value sequence in the test case editing information to obtain a target input element value sequence. The data cleaning interface may be encapsulated with a data cleaning function.
[0082] In the second step, each target input element value in the target input element value sequence is concatenated to obtain the test case creation information. The test case creation information may be a string concatenated from each element value. Each target input element value in the target input element value sequence may be concatenated using a preset character to obtain the test case creation information. The preset character may be a pre-set character. For example, the preset character may be “|”.
[0083] The third step is to input the newly created information of the above test case into the pre-trained expected response data generation model to obtain the expected response result. Among them, the above expected response data generation model may include an encoder and a decoder. The above encoder may be composed of a bidirectional gated recurrent unit based on an attention mechanism. The above decoder may be composed of a gated recurrent unit and a pointer generation network. The above expected response data generation model may be trained by conventional training methods based on a historical test case information set. The above historical test case information set may be information on each test case corresponding to the data application in the past period of time.
[0084] Step 104, in response to receiving the case confirmation information of the updated test case filling form, obtaining the current timestamp, and concatenating the preset custom case type identifier and the current timestamp to obtain the test case identifier.
[0085] In some embodiments, the execution subject may obtain the current timestamp in response to receiving the use case confirmation information of the form filled in for the updated test case, and concatenate the preset custom use case type identifier and the current timestamp to obtain the test case identifier. The use case confirmation information may include but is not limited to a form input item information set. The form input item information in the form input item information set may include a form item label and an element value. The current timestamp may be a timestamp of the current moment obtained from the cloud server. The preset custom use case type identifier may indicate that the test case type corresponding to the test case is a custom type.
[0086] The above-mentioned custom test case information may be information of a test case created by a user. First, a test case identifier corresponding to the custom test case is generated by a UUID (Universally Unique Identifier) algorithm. Then, the form input item information set including the preset custom test case type identifier, the above-mentioned test case identifier and the above-mentioned test case confirmation information may be determined as the custom test case information.
[0087] Step 105: Generate interface joint debugging data based on the test case identifier and the test case confirmation information.
[0088] In some embodiments, the execution subject may generate interface joint debugging data based on the test case identifier and the test case confirmation information. The interface joint debugging data may be the data required for joint debugging between the user terminal and the data application interface. First, the form input item information whose form item label meets the preset label condition is selected from the form input item information set included in the use case confirmation information as the user joint debugging requirement data to obtain the user joint debugging requirement data group. The preset label condition may be that the form item label is the same as any one of the test case title, test case input data, test case output data and interface URL. Then, the user joint debugging requirement data group and the test case identifier are determined as the interface joint debugging data.
[0089] Optionally, the execution entity may also determine the test case identifier and the form input item information set included in the test case confirmation information as test case detail information, and store the test case detail information in a test case detail information database.
[0090] Optionally, the above execution entity may further perform the following steps:
[0091] The first step is to update the interface test knowledge graph based on the interface joint debugging data to obtain an updated interface test knowledge graph. First, the test cases corresponding to the interface joint debugging data can be added to the interface test knowledge graph as entity nodes. Then, the entity node to be connected is determined according to the interface identifier corresponding to the interface joint debugging data. After that, the added entity node and the entity node to be connected are connected. Finally, the connected interface test knowledge graph is determined as the updated interface test knowledge graph.
[0092] In the second step, in response to receiving the joint debugging request for the target data application, based on the updated interface test knowledge graph, a sequence of test data to be debugged is generated, and the sequence of test data to be debugged is sent to the user end for the user end to perform data joint debugging with the data application interface corresponding to the target data application. Among them, the joint debugging request can be a network request sent by the user end to perform joint debugging with the target data application through the data application interface. The test data to be debugged in the sequence of test data to be debugged can be the interface joint debugging data corresponding to the target data application. First, according to the data application identifier corresponding to the target data application, the updated interface test knowledge graph is accurately retrieved and processed to obtain each test case identifier associated with the target data application. Then, for each test case identifier in the test case identifiers, the interface joint debugging data corresponding to the test case identifier is determined as the test data to be debugged. Afterwards, the test data to be debugged are sorted according to the early and late order of the timestamps when the interface joint debugging data is generated to obtain the sequence of test data to be debugged. Finally, the sequence of test data to be debugged is sent to the user end. The user can initiate an interface request through the user terminal according to the received test data to be jointly debugged, and perform data joint debugging with the data application interface corresponding to the above target data application.
[0093] The above-mentioned embodiments of the present disclosure have the following beneficial effects: through the interface joint debugging data generation method of some embodiments of the present disclosure, the user can generate interface joint debugging data according to his own test requirements, so as to facilitate timely discovery of problems in the local code through joint debugging. Specifically, the reason why it is difficult for the user end to maintain the local code in a timely manner is that since the positive test case data can only be used to test the expected normal behavior or function of the user end code, it is difficult for the user end to test the reliability of the local code under erroneous operation or abnormal conditions, thereby causing the user end to be difficult to maintain the local code in a timely manner. Based on this, the interface joint debugging data generation method of some embodiments of the present disclosure, first, in response to receiving the interface joint debugging test case query information corresponding to the target data application, the pre-generated interface test knowledge graph is retrieved to obtain the test case query result, and the test case query result is sent to the user end. Thus, the information of the test case matching the user joint debugging test requirements can be obtained. Then, in response to receiving an edit request for the above test case query result, a test case editing page is generated based on the above edit request, and the above test case editing page is sent to the user end. Wherein, the above test case editing page includes a test case filling form. Thus, when the queried test case cannot meet the user's test requirements, a test case editing page can be provided for the user, so that the user can modify the queried test case according to his own needs to create a test case that meets the user's needs. Afterwards, in response to receiving the test case editing information, the expected response result corresponding to the above test case editing information is determined, and the above expected response result is sent to the above user terminal for updating the above test case filling form. Thus, the expected response data corresponding to the test case can be generated according to the information of the test case edited by the user. Then, in response to receiving the case confirmation information for the above updated test case filling form, the current timestamp is obtained, and the preset custom case type identifier and the above current timestamp are spliced to obtain the test case identifier. Thus, a unique test case identifier can be assigned to the test case created by the user. Finally, based on the above test case identifier and the above case confirmation information, interface joint debugging data is generated. Thus, the test data required by the user for joint debugging according to the self-created test case can be obtained. Therefore, the interface debugging data generation method of some embodiments of the present invention provides users with a test case editing page, so that when users need to test the reliability of local code under erroneous operations or abnormal conditions, they can easily generate interface debugging data that meets their own debugging test needs, thereby facilitating the user end to perform timely maintenance of the local code.
[0094] Further references Figure 2 As an implementation of the methods shown in the above figures, the present disclosure provides some embodiments of an interface joint debugging data generation device, and these device embodiments are Figure 1 Corresponding to the method embodiments shown, the interface joint debugging data generating device 200 can be specifically applied to various electronic devices.
[0095] like Figure 2 As shown, the interface joint debugging data generating device 200 of some embodiments includes: a retrieval and sending unit 201, a first generating and sending unit 202, a determining and sending unit 203, an acquisition and splicing processing unit 204, and a second generating unit 205. Among them, the retrieval and sending unit 201 is configured to, in response to receiving the interface joint debugging test case query information corresponding to the target data application, retrieve the pre-generated interface test knowledge graph to obtain the test case query result, and send the above test case query result to the user end; the first generating and sending unit 202 is configured to, in response to receiving an edit request for the above test case query result, generate a test case editing page based on the above edit request, and send the above test case editing page to the user end, wherein the above test case editing page includes a test case filling form; the determining and sending unit 203 , configured to, in response to receiving the test case editing information, determine the expected response result corresponding to the above test case editing information, and send the above expected response result to the above user terminal for updating the above test case filling form; the acquisition and splicing processing unit 204, configured to, in response to receiving the case confirmation information for the above updated test case filling form, obtain the current timestamp, and splice the preset custom case type identifier and the above current timestamp to obtain the test case identifier; the second generation unit 205, configured to generate interface joint debugging data based on the above test case identifier and the above case confirmation information.
[0096] It can be understood that the units recorded in the interface joint debugging data generating device 200 are similar to the reference Figure 1 Therefore, the operations, features and beneficial effects described above for the method are also applicable to the interface joint debugging data generating device 200 and the units included therein, and will not be described in detail here.
[0097] Further references Figure 3 , which shows a structural schematic diagram of an electronic device 300 suitable for implementing some embodiments of the present disclosure. Figure 3 The electronic device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present disclosure.
[0098] like Figure 3As shown, the electronic device 300 may include a processing device (e.g., a central processing unit, a graphics processing unit, etc.) 301, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 302 or a program loaded from a storage device 308 into a random access memory (RAM) 303. In the RAM 303, various programs and data required for the operation of the electronic device 300 are also stored. The processing device 301, the ROM 302, and the RAM 303 are connected to each other via a bus 304. An input / output (I / O) interface 305 is also connected to the bus 304.
[0099] Typically, the following devices may be connected to the I / O interface 305: input devices 306 including, for example, a touch screen, a touch pad, a keyboard, a mouse, a camera, a microphone, an accelerometer, a gyroscope, etc.; output devices 307 including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; storage devices 308 including, for example, a magnetic tape, a hard disk, etc.; and communication devices 309. The communication devices 309 may allow the electronic device 300 to communicate with other devices wirelessly or by wire to exchange data. Although Figure 3 The electronic device 300 is shown with various devices, but it should be understood that it is not required to implement or possess all the devices shown. More or fewer devices may be implemented or possessed instead. Figure 3 Each block shown in the figure may represent one device, or may represent multiple devices as required.
[0100] In particular, according to some embodiments of the present disclosure, the process described above with reference to the flowchart can be implemented as a computer software program. For example, some embodiments of the present disclosure include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In some such embodiments, the computer program can be downloaded and installed from the network through the communication device 309, or installed from the storage device 308, or installed from the ROM 302. When the computer program is executed by the processing device 301, the above-mentioned functions defined in the method of some embodiments of the present disclosure are executed.
[0101] It should be noted that the computer-readable medium in some embodiments of the present disclosure may be a computer-readable signal medium or a computer-readable storage medium or any combination of the two. The computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In some embodiments of the present disclosure, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, device or device. In some embodiments of the present disclosure, the computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, in which a computer-readable program code is carried. This propagated data signal may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. The computer readable signal medium may also be any computer readable medium other than a computer readable storage medium, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.
[0102] In some embodiments, the client and the server may communicate using any currently known or future developed network protocol such as HTTP (HyperText Transfer Protocol), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), an internet (e.g., the Internet), and a peer-to-peer network (e.g., an ad hoc peer-to-peer network), as well as any currently known or future developed network.
[0103] The computer-readable medium may be included in the device, or may exist independently without being incorporated into the electronic device. The computer-readable medium carries one or more programs. When the one or more programs are executed by the electronic device, the electronic device: in response to receiving interface joint debugging test case query information corresponding to the target data application, retrieve the pre-generated interface test knowledge graph to obtain the test case query result, and send the test case query result to the user end; in response to receiving an edit request for the test case query result, generate a test case editing page based on the edit request, and send the test case editing page to the user end, wherein the test case editing page includes a test case filling form; in response to receiving the test case editing information, determine the expected response result corresponding to the test case editing information, and send the expected response result to the user end for updating the test case filling form; in response to receiving the case confirmation information for the updated test case filling form, obtain the current timestamp, and concatenate the preset custom case type identifier and the current timestamp to obtain the test case identifier; based on the test case identifier and the case confirmation information, generate interface joint debugging data.
[0104] Computer program code for performing the operations of some embodiments of the present disclosure may be written in one or more programming languages or a combination thereof, including object-oriented programming languages such as Java, Smalltalk, C++, and conventional procedural programming languages such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a separate software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).
[0105] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present disclosure. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some implementations as replacements, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.
[0106] The units described in some embodiments of the present disclosure may be implemented by software or by hardware. The described units may also be arranged in a processor, for example, may be described as: a processor comprising: a retrieval and sending unit, a first generation and sending unit, a determination and sending unit, an acquisition and splicing processing unit, and a second generation unit. Among them, the names of these units do not constitute a limitation on the unit itself under certain circumstances. For example, the retrieval and sending unit may also be described as "a unit for searching a pre-generated interface test knowledge graph, obtaining a test case query result, and sending the above test case query result to the user end".
[0107] The functions described above herein may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on chips (SOCs), complex programmable logic devices (CPLDs), and the like.
[0108] The above descriptions are only some preferred embodiments of the present disclosure and an explanation of the technical principles used. Those skilled in the art should understand that the scope of the invention involved in the embodiments of the present disclosure is not limited to the technical solutions formed by a specific combination of the above-mentioned technical features, but should also cover other technical solutions formed by any combination of the above-mentioned technical features or their equivalent features without departing from the above-mentioned inventive concept. For example, the above-mentioned features are replaced with the technical features with similar functions disclosed in the embodiments of the present disclosure (but not limited to) and the technical solutions formed.
Claims
1. A method for generating interface joint debugging data, include: In response to receiving the interface joint debugging test case query information corresponding to the target data application, searching the pre-generated interface test knowledge graph to obtain the test case query result, and sending the test case query result to the user end; In response to receiving an edit request for the test case query result, generating a test case edit page based on the edit request, and sending the test case edit page to the user end, wherein the test case edit page includes a test case filling form; In response to receiving the test case editing information, determining an expected response result corresponding to the test case editing information, and sending the expected response result to the user terminal for updating the test case filling form; In response to receiving the use case confirmation information of the filled-in form for the updated test case, obtaining the current timestamp, and concatenating the preset custom use case type identifier and the current timestamp to obtain the test case identifier; Based on the test case identifier and the test case confirmation information, interface joint debugging data is generated.
2. The method according to claim 1, in, The method further comprises: Based on the interface joint debugging data, the interface test knowledge graph is updated to obtain an updated interface test knowledge graph; In response to receiving a joint debugging request for the target data application, a test data sequence to be joint debugged is generated based on the updated interface test knowledge graph, and the test data sequence to be joint debugged is sent to the user terminal for the user terminal to perform data joint debugging with the data application interface corresponding to the target data application.
3. The method according to claim 1, in, The interface joint debugging test case query information includes a data application identifier and a query text; And the pre-generated interface test knowledge graph is searched to obtain the test case query results, including: Perform keyword extraction processing on the query text included in the interface joint debugging test case query information to obtain a keyword result set; For each keyword result in the keyword result set, searching the interface test knowledge graph based on the keyword result to obtain a first search result; Based on the data application identifier included in the interface joint debugging test case query information, the interface test knowledge graph is searched to obtain a second search result set; A test case query result is generated based on each of the first search results and the second search result set.
4. The method according to claim 1, in, The generating a test case editing page based on the editing request includes: Acquire test case detail information corresponding to the editing request, wherein the test case detail information includes an attribute information group; For each form input element included in the preset test case form template, perform the following steps to update the form input element: Selecting attribute information matching the form input element from the attribute information group included in the test case details information as target attribute information; Based on the target attribute information, determining an element value corresponding to the form input element, and updating a value attribute corresponding to the form input element; In response to determining that the form input element satisfies a preset element condition, adding a read-only attribute to the form input element; In response to determining that the form input element does not satisfy the preset element condition, setting a content editable attribute corresponding to the form input element to true; In response to detecting that each form input element included in the test case form template has been updated, generating a verification code image to be identified; Binding the verification code image to be identified to the verification code image element included in the test case form template, and determining the updated test case form template as the test case filling form; Fill the test case filling form into the preset test case editing page template to obtain the test case editing page.
5. The method according to claim 1, in, The test case editing information includes an input element value sequence; And the determining of the expected response result corresponding to the test case editing information includes: Performing data cleaning processing on each input element value included in the input element value sequence in the test case editing information to obtain a target input element value sequence; Concatenate each target input element value in the target input element value sequence to obtain test case creation information; The newly created information of the test case is input into a pre-trained expected response data generation model to obtain an expected response result, wherein the expected response data generation model includes an encoder and a decoder, the encoder is composed of a bidirectional gated recurrent unit based on an attention mechanism, the decoder is composed of a gated recurrent unit and a pointer generation network, and the expected response data generation model is trained based on a historical test case information set.
6. The method according to any one of claims 1 to 5, in, The interface test knowledge graph is pre-generated through the following steps: Acquire an application interface relationship information set, an interface test case relationship information set, and a data application information set, wherein the interface test case relationship information in the interface test case relationship information set includes an interface identifier, a test case identifier, and a test case type identifier, the application interface relationship information in the application interface relationship information set includes a data application identifier and an interface identifier, and the data application information in the data application information set includes a data application identifier and an adapter subject type identifier; Determine each data application identifier in the application interface relationship information set as a first entity identifier set; Determine each interface identifier in the application interface relationship information set as a second entity identifier set; Determine each test case identifier in the interface test case relationship information set as a third entity identifier set; Determine each adapter subject type identifier in the data application information set as a fourth entity identifier set; For each piece of application interface relationship information in the application interface relationship information set, determining a first preset weight value, a data application identifier and an interface identifier included in the application interface relationship information as first entity relationship information; For each piece of data application information in the data application information set, determining the first preset weight value, the data application identifier and the adaptation subject type identifier included in the data application information as second entity relationship information; For each interface test case relationship information in the interface test case relationship information set, perform the following steps: In response to determining that the test case type identifier included in the interface test case relationship information satisfies a preset custom type condition, determining the second preset weight value, the interface identifier and the test case identifier included in the interface test case relationship information as third entity relationship information; In response to determining that the test case type identifier included in the interface test case relationship information does not meet the preset custom type condition, determining the first preset weight value, the interface identifier and the test case identifier included in the interface test case relationship information as fourth entity relationship information; Based on the first entity identification set, the second entity identification set, the third entity identification set, the fourth entity identification set, the obtained first entity relationship information, second entity relationship information, third entity relationship information and fourth entity relationship information, an interface testing knowledge graph is generated.
7. An interface joint debugging data generating device, include: The retrieval and sending unit is configured to, in response to receiving the interface joint debugging test case query information corresponding to the target data application, retrieve the pre-generated interface test knowledge graph to obtain the test case query result, and send the test case query result to the user end; A first generating and sending unit is configured to generate a test case editing page in response to receiving an editing request for the test case query result, based on the editing request, and send the test case editing page to the user end, wherein the test case editing page includes a test case filling form; A determination and sending unit, configured to, in response to receiving the test case editing information, determine the expected response result corresponding to the test case editing information, and send the expected response result to the user terminal for updating the test case filling form; An acquisition and splicing processing unit is configured to, in response to receiving the case confirmation information of the updated test case filling form, acquire the current timestamp, and splice the preset custom case type identifier and the current timestamp to obtain the test case identifier; The second generating unit is configured to generate interface joint debugging data based on the test case identifier and the test case confirmation information.
8. An electronic device, include: one or more processors; a storage device having one or more programs stored thereon, When the one or more programs are executed by the one or more processors, the one or more processors implement the method according to any one of claims 1 to 6.
9. A computer readable medium having a computer program stored thereon, in, When the computer program is executed by a processor, the method according to any one of claims 1 to 6 is implemented.
Citation Information
Patent Citations
Test case generation method and device, electronic equipment and storage medium
CN109614312A
Test case management method, device and equipment
CN112148593A
Verification method and device based on confrontation verification code, equipment and medium
CN116167037A
Software testing method and device based on knowledge graph, equipment and storage medium
CN116860632A
Method and system for testing application programming interface
CN118349448A
Cited By
Data joint debugging test method and system, terminal equipment and storage medium
CN121681397A
