ATE software version compatibility guarantee method and system

Abstract

The invention provides an ATE software version compatibility guarantee method and system, and the method comprises the steps: carrying out the initialization management of AP I of a plurality of versions in ATE software, and forming a version mapping table; the version mapping table comprises a mapping relation between the new version AP I and the old version AP I; analyzing an AP I request in the ATE test project, and obtaining a version of the AP I request; searching a target AP I of which the version is the same as that of the AP I request in a version mapping table; if the target AP I is found, directly calling the target AP I; and if the target AP I is not found, finding an old-version AP I having a mapping relationship with the target AP I based on the mapping relationship, and calling the old-version AP I. Compared with the prior art, by managing the multiple versions of AP I and creating the mapping relation between the new version of AP I and the old version of AP I, automatic compatibility between the old version of test engineering and the new version of ATE software is achieved, and the use experience of a user is improved.

Description

Technical Field

[0001] The present invention relates to the technical field of version compatibility, and in particular to a method and system for ensuring version compatibility of ATE software. Background Art

[0002] In the process of upgrading ATE (Automatic Test Equipment) software versions, ensuring that the new version of the software can be compatible and run correctly on the old version of the test project is a key issue. Existing solutions mainly focus on manual compatibility testing, and it is currently difficult to achieve automated compatibility between software versions and test project versions.

[0003] Existing manual compatibility testing has some shortcomings, such as low efficiency, reliance on manual testing, prone to errors, and limited use scenarios. In addition, there is a lack of detection methods and mechanisms for some minor compatibility issues, making it difficult to dynamically respond to compatibility issues caused by API changes.

[0004] Based on this, it is urgent to propose a solution to solve at least one of the above problems. Summary of the invention

[0005] In order to overcome the above-mentioned defects of the prior art, the present invention provides a method and system for ensuring the compatibility of ATE software versions, which can realize the automatic compatibility between the new version ATE software and the old version test project.

[0006] The specific technical solutions are as follows:

[0007] A first aspect of the present invention provides a method for ensuring compatibility of ATE software versions, the method comprising:

[0008] Initialize and manage multiple versions of API in ATE software to form a version mapping table; the version mapping table contains a mapping relationship between a new version of API and an old version of API;

[0009] Parse the API request in the ATE test project and obtain the version of the API request;

[0010] Searching the version mapping table for a target API with the same version as the API request; if the target API is found, directly calling the target API; if the target API is not found, finding an old version API with a mapping relationship with the target API based on the mapping relationship, and calling the old version API.

[0011] In a specific embodiment, the “initialization management of multiple versions of APIs in ATE software” includes: setting a version identifier for each version of the API and recording parameters of each version of the API; and determining the mapping relationship is related to the difference in parameters between the new and old versions of the API.

[0012] In a specific embodiment, the “determination of the mapping relationship” specifically includes:

[0013] If the functions of the two APIs are the same or similar, but the structures of the parameters are different, it is determined that there is a mapping relationship between the two APIs.

[0014] In a specific embodiment, the “different structures of parameters” specifically include:

[0015] In the two APIs, the parameters of one are included in the parameters of the other.

[0016] In a specific embodiment, the “finding, based on the mapping relationship, an old version API having a mapping relationship with the target API” further includes:

[0017] If there are multiple old version APIs having a mapping relationship with the target API, an old version API that is closest to the target API version is selected according to the version identifier.

[0018] In a specific embodiment, before the “calling the old version API”, the method further includes:

[0019] The incoming parameters of the API request are adjusted so that the number and type of the incoming parameters are adapted to the number and type of the old version API parameters.

[0020] In a specific embodiment, the “adjusting the incoming parameters of the API request” specifically includes:

[0021] The incoming parameters and calling mode of the API request are dynamically adjusted through an adaptive learning algorithm.

[0022] In a specific embodiment, the “directly calling the target API” further includes:

[0023] If the target API call fails, an old version API having a mapping relationship with the target API is called again.

[0024] In a specific embodiment, the method further comprises:

[0025] The mapping relationship in the version mapping table is automatically adjusted as a new version of the API is added.

[0026] A second aspect of the present invention provides an ATE software version compatibility assurance system, comprising:

[0027] A version management module, used to initialize and manage multiple versions of API in ATE software to form a version mapping table; the version mapping table contains a mapping relationship between a new version of API and an old version of API;

[0028] A parsing module, used to parse the API request in the ATE test project and obtain the version of the API request;

[0029] The calling module is used to search the target API with the same version as the API request in the version mapping table; if the target API is found, directly call the target API; if the target API is not found, find the old version API with a mapping relationship with the target API based on the mapping relationship, and call the old version API.

[0030] The present invention has at least the following beneficial effects:

[0031] The present invention provides a method and system for ensuring the compatibility of ATE software versions, wherein the method manages multiple versions of APIs and creates a mapping relationship between new and old versions of APIs, thereby being able to find an adapted API version for the API request of the old version test project, thereby achieving automatic compatibility between the old version test project and the new version of ATE software, solving the problems of low efficiency and high error rate of manual testing, and solving the compatibility problems caused by dynamic changes of APIs, thereby greatly improving the user experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0032] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0033] Figure 1 A schematic diagram of the process provided by the present invention;

[0034] Figure 2 A schematic diagram of the structure of the system provided by the present invention.

[0035] Reference numerals:

[0036] 1-version management module; 2-parsing module; 3-calling module. DETAILED DESCRIPTION

[0037] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0038] In the description of the present invention, it should be noted that the terms "vertical", "up", "down", "horizontal", etc. indicate orientations or positional relationships based on the orientations or positional relationships shown in the accompanying drawings, and are only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore cannot be understood as a limitation on the present invention.

[0039] In the description of the present invention, it is also necessary to explain that, unless otherwise clearly specified and limited, the terms "set", "install", "connect", and "connect" should be understood in a broad sense, for example, it can be a fixed connection, a detachable connection, or an integral connection; it can be a mechanical connection or an electrical connection; it can be a direct connection, or it can be indirectly connected through an intermediate medium, or it can be the internal communication of two elements. For ordinary technicians in this field, the specific meanings of the above terms in the present invention can be understood according to specific circumstances.

[0040] Please refer to Figure 1 The present invention provides a method for ensuring the compatibility of ATE software versions, the method specifically comprising:

[0041] S1: Initialize multiple versions of APIs in the management ATE software to form a version mapping table; the version mapping table contains a mapping relationship between a new version of API and an old version of API.

[0042] Exemplarily, the API (Application Programming Interface) manager can be used to initialize and manage multiple versions of API in the ATE software. Exemplarily, the specific content of initializing and managing multiple versions of API in the ATE software includes, but is not limited to, setting a version identifier for each version of the API, recording parameters of each version of the API, and defining the calling method of the API. Exemplarily, the version identifier can be, for example, "v1", "v2", "v3", ... and so on.

[0043] It is understandable that as the ATE software is updated, the API version will also be dynamically updated. Therefore, initializing the management of multiple versions of the API in the ATE software can be understood as a process of dynamically managing the API. During this process, changes such as updates, additions, and deletions may occur between different versions of the API.

[0044] In addition, the multiple versions of API described in this step include new version API and old version API, and the new and old are only relative terms, that is, only the new and old versions of the two APIs are compared, and the comparison method can be, for example, determined by version identification. In this step, a version mapping table is formed, and the version mapping table contains the mapping relationship between the new version API and the old version API. The mapping relationship can be understood as that the new version API and the old version API have an association, and this association enables calling the old version API to achieve the same or similar functions as calling the new version API.

[0045] S2: Parse the API request in the ATE test project and obtain the version of the API request. Exemplarily, the specific method of obtaining the version of the API request may be: identify the API version identifier included in the API request.

[0046] S3: Search the version mapping table for a target API with the same version as the API request; if the target API is found, call the target API directly; if the target API is not found, find an old version API with a mapping relationship with the target API based on the mapping relationship, and call the old version API.

[0047] Exemplarily, the specific process of "searching for a target API with the same version as the API request in the version mapping table" may be: searching for an API with the same version identifier as the API request in the version mapping table. Specifically, if there is an API with this version identifier, then this API is the target API, and it is preliminarily determined that there is no compatibility issue, and the target API can be called directly at this time. If there is no API with this version identifier (for example, the API has been deleted in the new version), then it is determined that there is a compatibility issue, and then based on the mapping relationship, an old version of the API with a mapping relationship with the target API is found, and compatibility is achieved through the old version of the API.

[0048] In a specific embodiment, the determination of the mapping relationship is related to the difference in parameters between the new and old versions of the API.

[0049] Specifically, the determination of the mapping relationship may include: if the functions of the two APIs are the same or similar, but the structures of the parameters are different, then determining that there is a mapping relationship between the two APIs.

[0050] Specifically, the “different structures of parameters” may include: in two APIs, the parameters of one are included in the parameters of the other.

[0051] Here are some examples:

[0052] Assume there is an API interface "GetUserData", which is defined as follows in versions v1, v2, and v3:

[0053] v1: GetUserData(userId);

[0054] v2: GetUserData(userId,includeHistory);

[0055] v3:GetUserData(userId,includeHistory,includePreferences);

[0056] It can be seen that the API in all three versions is used to obtain user data. In addition, the parameters of the API in version v1 are included in the parameters of the API in versions v2 and v3; the parameters of the API in version v2 are included in the parameters of the API in version v3. Therefore, the following mapping relationship can be obtained:

[0057] v3->v2; v3->v1; v2->v1;

[0058] At this time, if the API request calls the API under the v3 version, it is determined whether the v3 version of the API exists. If it does, it is called directly. If the v3 version of the API does not exist, is unavailable, or an error occurs, the v2 version or v1 version that has a mapping relationship with the v3 version can be found. Taking the v2 version as an example, the API request will be mapped to the v2 version of GetUserData (userId, includeHistory). Before calling the v2 version of the API, the incoming parameters of the API request will be adjusted so that the number and type of its incoming parameters are adapted to the number and type of the v2 version of the API parameters. In this example, the "includePreferences" parameter is ignored, so that the API call can be completed, solving the compatibility problem.

[0059] In another case, if an API request calls the API under version v3, but the incoming parameters of the API request are missing some parameters (such as "includePreferences"), and the parameters are not necessary, the API request can also be mapped at this time, such as mapping v2: GetUserData(userId, includeHistory), so that the call can be completed.

[0060] In a specific embodiment, the "finding an old version API having a mapping relationship with the target API based on the mapping relationship" also includes: if there are multiple old version APIs having a mapping relationship with the target API, selecting the old version API closest to the target API version according to the version identifier.

[0061] Specifically, still using the above example to illustrate, the v3 version of the API has a mapping relationship with the v2 and v1 versions of the API. Since the v3 version is closer to the v2 version, under normal circumstances, the difference between the v3 version of the API and the v2 version of the API will be smaller than the difference between the v3 version of the API and the v1 version of the API. It can also be seen from the above example that compared with the v2 version, the v3 version has only one more API parameter, while compared with the v2 version, the v3 version has two more API parameters. Therefore, it will be preferred to map the API request to the older version of the API that is closest to its version.

[0062] In a specific embodiment, the “adjusting the incoming parameters of the API request” may specifically include: dynamically adjusting the incoming parameters and calling method of the API request through an adaptive learning algorithm.

[0063] Specifically, the adaptive learning algorithm can monitor the updates of the API in the version mapping table, for example, by monitoring the API through an API manager. When the adaptive learning algorithm detects an API update, it will parse the API document to understand the changes in the parameters, which may include the addition and deletion of parameters, name changes, type changes, etc. When adjusting the incoming parameters of the API request, the adaptive learning algorithm can map the incoming parameters provided by the API request to the parameters required by the API based on the learned update parameter mapping rules. This process involves matching and converting parameter names, types, and orders to achieve the mapping of API requests to target APIs.

[0064] In a specific embodiment, the “directly calling the target API” further includes:

[0065] If the target API fails to call, then call the old version API that has a mapping relationship with the target API again. Understandably, in the case of the target API, the call failure problem may still occur, so the old version of the API can be converted to call when the target API fails to call to avoid deadlock.

[0066] In a specific embodiment, the method further comprises:

[0067] The mapping relationship in the version mapping table is automatically adjusted as the new version of the API is added. It is understandable that as the ATE software is updated, the version of the API will also be dynamically updated, so the API data in the version mapping table will also be updated. After the new version of the API is added to the version mapping table, the mapping relationship between different versions of the API can be readjusted based on the mapping relationship determination rules described in the above embodiment to further improve the degree of automation. Optionally, the mapping relationship determination rules can be as described in the above embodiment, or other algorithms can be adopted, which are not specifically limited here.

[0068] Please refer to Figure 2 The present invention also provides an ATE software version compatibility assurance system, comprising:

[0069] The version management module 1 is used to initialize and manage multiple versions of API in the ATE software to form a version mapping table, which includes a mapping relationship between a new version of API and an old version of API.

[0070] The parsing module 2 is used to parse the API request in the ATE test project and obtain the version of the API request.

[0071] The calling module 3 is used to search the target API with the same version as the API request in the version mapping table; if the target API is found, the target API is directly called; if the target API is not found, an old version API with a mapping relationship with the target API is found based on the mapping relationship, and the old version API is called.

[0072] In a specific embodiment, the version management module 1 is used to set a version identifier for each version of the API and record the parameters of each version of the API. The determination of the mapping relationship is related to the difference in parameters between the new and old versions of the API. Further, the "determination of the mapping relationship" specifically includes: if the functions of the two APIs are the same or similar, but the structures of the parameters are different, then it is determined that there is a mapping relationship between the two APIs. Further, the "different structures of the parameters" specifically includes: in the two APIs, the parameters of one are included in the parameters of the other.

[0073] In a specific embodiment, the calling module 3 is further used to determine whether there are multiple old version APIs that have a mapping relationship with the target API, and if so, select the old version API that is closest to the target API version according to the version identifier.

[0074] In a specific embodiment, the calling module 3 is further used to adjust the incoming parameters of the API request before calling the old version API, so that the number and type of the incoming parameters are adapted to the number and type of the old version API parameters. Further, the "adjusting the incoming parameters of the API request" specifically includes: dynamically adjusting the incoming parameters of the API request and the calling method through an adaptive learning algorithm.

[0075] In a specific embodiment, the calling module 3 is further configured to re-call an old version of the API that has a mapping relationship with the target API when the calling of the target API fails.

[0076] In a specific embodiment, the version management module 1 is also used to automatically adjust the mapping relationship in the version mapping table as a new version of the API is added.

[0077] In summary, the present invention provides a method and system for ensuring the compatibility of ATE software versions, wherein the method manages multiple versions of APIs and creates a mapping relationship between new and old versions of APIs, thereby being able to find an adapted API version for an API request of an old version test project, thereby achieving automatic compatibility between the old version test project and the new version of ATE software, solving the problems of low efficiency and high error rate of manual testing, solving the compatibility problems caused by dynamic changes of APIs, and greatly improving the user experience.

[0078] It should be understood by those skilled in the art that the modules or steps of the present invention described above can be implemented by a general-purpose computing device, they can be concentrated on a single computing device, or distributed on a network composed of multiple computing devices, optionally, they can be implemented by a program code executable by a computer device, so that they can be stored in a storage device and executed by the computing device, or they can be made into individual integrated circuit modules, or multiple modules or steps therein can be made into a single integrated circuit module for implementation. Thus, the present invention is not limited to any specific combination of hardware and software.

[0079] Note that the above are only preferred embodiments of the present invention and the technical principles used. Those skilled in the art will understand that the present invention is not limited to the specific embodiments herein, and that various obvious changes, readjustments and substitutions can be made by those skilled in the art without departing from the scope of protection of the present invention. Therefore, although the present invention has been described in more detail through the above embodiments, the present invention is not limited to the above embodiments, and may include more other equivalent embodiments without departing from the concept of the present invention, and the scope of the present invention is determined by the scope of the appended claims.

[0080] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for ensuring compatibility of ATE software versions, characterized in that: The method comprises: Initialize and manage multiple versions of API in ATE software to form a version mapping table; the version mapping table contains a mapping relationship between a new version of API and an old version of API; Parse the API request in the ATE test project and obtain the version of the API request; Search the version mapping table for a target API with the same version as the API request; if the target API is found, directly call the target API; if the target API is not found, find an old version API with a mapping relationship with the target API based on the mapping relationship, and call the old version API.

2. A method for ensuring ATE software version compatibility according to claim 1, characterized in that: The "initialization management of multiple versions of API in ATE software" includes: setting a version identifier for each version of API and recording parameters of each version of API; the determination of the mapping relationship is related to the difference in parameters between the new and old versions of API.

3. The method for ensuring the compatibility of ATE software versions according to claim 2, characterized in that: The “determination of the mapping relationship” specifically includes: If the functions of the two APIs are the same or similar but the structures of the parameters are different, it is determined that there is a mapping relationship between the two APIs.

4. The method for ensuring compatibility of ATE software versions according to claim 3, characterized in that: The "different structures of parameters" specifically include: In both of the APIs, the parameters of one are contained in the parameters of the other.

5. The method for ensuring the compatibility of ATE software versions according to claim 2, characterized in that: The “finding an old version API having a mapping relationship with the target API based on the mapping relationship” also includes: If there are multiple old version APIs that have a mapping relationship with the target API, the old version API that is closest to the target API version is selected according to the version identifier.

6. The method for ensuring compatibility of ATE software versions according to claim 1, characterized in that: Before "calling the old version API", it also includes: The input parameters of the API request are adjusted so that the quantity and type of the input parameters are adapted to the quantity and type of the old version API parameters.

7. The method for ensuring compatibility of ATE software versions according to claim 6, characterized in that: The “adjusting the incoming parameters of the API request” specifically includes: The incoming parameters and calling method of the API request are dynamically adjusted through an adaptive learning algorithm.

8. The method for ensuring compatibility of ATE software versions according to claim 1, characterized in that: The “directly calling the target API” also includes: If the target API call fails, then the old version API that has a mapping relationship with the target API is called again.

9. The method for ensuring compatibility of ATE software versions according to claim 1, characterized in that: The method further comprises: The mapping relationship in the version mapping table is automatically adjusted as a new version of the API is added.

10. An ATE software version compatibility assurance system, characterized in that: include: A version management module, used to initialize and manage multiple versions of API in ATE software to form a version mapping table; the version mapping table contains a mapping relationship between a new version of API and an old version of API; A parsing module, used to parse the API request in the ATE test project and obtain the version of the API request; A calling module, used for searching the version mapping table for a target API with the same version as the API request; If the target API is found, the target API is called directly; If the target API is not found, an old version API having a mapping relationship with the target API is found based on the mapping relationship, and the old version API is called.

Images