CN114201384A

CN114201384A - Test method, test device, electronic equipment and storage medium

Info

Publication number: CN114201384A
Application number: CN202111370140.4A
Authority: CN
Inventors: 王倩云; 裴大卫
Original assignee: Beijing Sankuai Online Technology Co Ltd
Current assignee: Beijing Sankuai Online Technology Co Ltd
Priority date: 2021-11-18
Filing date: 2021-11-18
Publication date: 2022-03-18

Abstract

The embodiment of the disclosure provides a test method, a test device, electronic equipment and a storage medium. The test method comprises the following steps: aiming at a component to be tested in a container to be tested, screening out a target page which refers to the component to be tested, and taking the target page as a page to be tested; and jumping to the page to be tested, and testing the page to be tested. In the embodiment of the disclosure, considering that the modified to-be-tested component may be only referred to by a part of pages, the page range affected by the to-be-tested component is accurately positioned in the testing process, and the to-be-tested page is screened out, so that only the to-be-tested page needs to be tested, the number of tested pages can be reduced, and the testing efficiency is improved.

Description

Test method, test device, electronic equipment and storage medium

Technical Field

The present disclosure relates to the field of internet technologies, and in particular, to a testing method and apparatus, an electronic device, and a storage medium.

Background

With the rapid development of the internet technology, the container technology has become the foundation and standard of cloud, and the rapid development of the internet business and innovation thereof is promoted.

Containers involve a large number of components and pages. Pages developed using containers have performance and interactive experience comparable to native, and have very wide application in various application programs (APPs), so the overall quality and stability of the container is of utmost importance. With the rapid development of services, the containers are also continuously optimized in an iterative manner, each optimization is closely related to the upper-layer services, and the containers need to be tested after each optimization.

In the prior art, when the components in the container are changed, the test is usually performed on the whole number of pages, but the test efficiency is low due to the large number of pages.

Disclosure of Invention

In view of the foregoing problems, embodiments of the present disclosure provide a testing method, an apparatus, an electronic device, and a storage medium, so as to reduce the number of pages to be tested and improve the testing efficiency.

According to a first aspect of embodiments of the present disclosure, there is provided a test method, including:

aiming at a component to be tested in a container to be tested, screening out a target page which refers to the component to be tested, and taking the target page as a page to be tested;

and jumping to the page to be tested, and testing the page to be tested.

Optionally, the screening out a target page that refers to the component to be tested includes: inquiring a target page which refers to the to-be-tested component based on a first mapping relation which is created in advance; wherein the first mapping relationship represents a mapping relationship between a page and a component referenced by the page.

Optionally, the first mapping relationship is created by: performing document analysis on the source codes corresponding to the components in the container to be tested, and extracting the names and attributes of the components; analyzing a grammatical structure of a source code corresponding to a page in the container to be tested based on the name and the attribute of each component, and extracting the name and the attribute of the component quoted by each page; and creating the first mapping relation based on the names and the attributes of the components referenced by the pages.

Optionally, the document parsing the source code corresponding to the component in the to-be-tested container and extracting the name and the attribute of each component includes: converting a source code corresponding to the component in the container to be tested into a document tree in a JSON format; and searching a node representing the component name from the document tree, and searching a node representing the component attribute corresponding to the component name from the child node of the node representing the component name to obtain the name and the attribute of each component.

Optionally, the parsing a syntax structure of a source code corresponding to a page in the container to be tested based on the name and the attribute of each component, and extracting the name and the attribute of the component referred by each page includes: converting a source code corresponding to a page in the container to be tested into an abstract syntax tree; extracting the names of source codes corresponding to the components introduced by the abstract syntax tree and the names of the components based on a preset first syntax rule; the first syntax rule represents the name of a source code corresponding to the component introduced by the abstract syntax tree and a rule which needs to be met by the name of the component; extracting a variable name corresponding to the instantiated component object of the abstract syntax tree based on a preset second syntax rule; the second syntax rule represents a rule which needs to be satisfied by a variable name corresponding to a component object instantiated by the abstract syntax tree; extracting the attribute of the instantiated component of the abstract syntax tree based on a preset third syntax rule; the third syntax rule represents a rule that the attribute of the component instantiated in the abstract syntax tree needs to satisfy, and the third syntax rule is set based on the variable name and the name and attribute of each component.

Optionally, the jumping to the page to be tested includes: inquiring a target jump protocol case corresponding to the page to be tested based on a second mapping relation established in advance; the second mapping relation represents the mapping relation between the page and the jump protocol use case; and jumping to the page to be tested through the target jumping protocol.

Optionally, the second mapping relationship is created by: receiving page information reported by a client, wherein the page information comprises a page identifier and a jump protocol use case corresponding to a page; extracting page information corresponding to an effective page from the page information reported by the client; and creating the second mapping relation based on the page information corresponding to the effective page.

According to a second aspect of embodiments of the present disclosure, there is provided a test apparatus including:

the screening module is used for screening out a target page which refers to the components to be tested aiming at the components to be tested in the container to be tested, and taking the target page as the page to be tested;

and the testing module is used for jumping to the page to be tested and testing the page to be tested.

Optionally, the screening module is specifically configured to query a target page referencing the component to be tested based on a pre-created first mapping relationship; wherein the first mapping relationship represents a mapping relationship between a page and a component referenced by the page.

Optionally, the first mapping relationship is created by: the first analysis module is used for carrying out document analysis on the source codes corresponding to the components in the container to be tested and extracting the names and the attributes of the components; the second analysis module is used for carrying out syntactic structure analysis on the source code corresponding to the page in the container to be tested based on the name and the attribute of each component, and extracting the name and the attribute of the component quoted by each page; and the first creating module is used for creating the first mapping relation based on the name and the attribute of the component referenced by each page.

Optionally, the first parsing module includes: the first conversion unit is used for converting the source code corresponding to the component in the container to be tested into a document tree in a JSON format; and the searching unit is used for searching the node representing the component name from the document tree, searching the node representing the component attribute corresponding to the component name from the child node of the node representing the component name, and obtaining the name and the attribute of each component.

Optionally, the second parsing module includes: the second conversion unit is used for converting the source code corresponding to the page in the container to be tested into an abstract syntax tree; the first extraction unit is used for extracting the names of the source codes corresponding to the components introduced by the abstract syntax tree and the names of the components based on a preset first syntax rule; the first syntax rule represents the name of a source code corresponding to the component introduced by the abstract syntax tree and a rule which needs to be met by the name of the component; the second extraction unit is used for extracting variable names corresponding to the component objects instantiated by the abstract syntax tree based on a preset second syntax rule; the second syntax rule represents a rule which needs to be satisfied by a variable name corresponding to a component object instantiated by the abstract syntax tree; the third extraction unit is used for extracting the attribute of the component instantiated by the abstract syntax tree based on a preset third syntax rule; the third syntax rule represents a rule that the attribute of the component instantiated in the abstract syntax tree needs to satisfy, and the third syntax rule is set based on the variable name and the name and attribute of each component.

Optionally, the test module is specifically configured to query, based on a second mapping relationship created in advance, a target jump protocol case corresponding to the page to be tested; the second mapping relation represents the mapping relation between the page and the jump protocol use case; and jumping to the page to be tested through the target jumping protocol.

Optionally, the second mapping relationship is created by: the system comprises a receiving module, a sending module and a processing module, wherein the receiving module is used for receiving page information reported by a client, and the page information comprises a page identifier and a jump protocol use case corresponding to a page; the extraction module is used for extracting page information corresponding to an effective page from the page information reported by the client; and the second creating module is used for creating the second mapping relation based on the page information corresponding to the effective page.

According to a third aspect of embodiments of the present disclosure, there is provided an electronic apparatus including: one or more processors; and one or more computer-readable storage media having instructions stored thereon; the instructions, when executed by the one or more processors, cause the processors to perform a test method as any one of above.

According to a fourth aspect of embodiments of the present disclosure, there is provided a computer readable storage medium having stored thereon a computer program which, when executed by a processor, causes the processor to perform a test method as defined in any one of the above.

The embodiment of the disclosure provides a test method, a test device, electronic equipment and a storage medium. In the testing process, aiming at a component to be tested in a container to be tested, screening out a target page which refers to the component to be tested, and taking the target page as a page to be tested; and jumping to the page to be tested, and testing the page to be tested. Therefore, in the embodiment of the disclosure, considering that the modified to-be-tested component may only be referred by a part of pages, the page range affected by the to-be-tested component is accurately positioned in the testing process, and the to-be-tested page is screened out, so that only the to-be-tested page needs to be tested, the number of tested pages can be reduced, and the testing efficiency is improved.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the drawings needed to be used in the description of the embodiments of the present disclosure will be briefly introduced below, and it is obvious that the drawings in the following description are only some drawings of the embodiments of the present disclosure, and other drawings can be obtained according to these drawings by those skilled in the art without inventive exercise.

FIG. 1 is a flow chart of the steps of a testing method of an embodiment of the present disclosure.

Fig. 2 is an overall frame diagram of an embodiment of the present disclosure.

Fig. 3 is a schematic diagram of a component information parsing process according to an embodiment of the present disclosure.

FIG. 4 is a schematic diagram of a document tree of an embodiment of the present disclosure.

Fig. 5 is a schematic diagram of a component information parsing result according to an embodiment of the present disclosure.

FIG. 6 is a schematic diagram of a page reference analysis process of an embodiment of the present disclosure.

Fig. 7 is a schematic diagram of a page reference analysis result according to an embodiment of the present disclosure.

Fig. 8 is a schematic diagram of a Scheme dynamic reporting analysis process according to an embodiment of the present disclosure.

FIG. 9 is a schematic diagram of a data storage portion of an embodiment of the present disclosure.

FIG. 10 is a schematic diagram of a component and page analysis results of an embodiment of the present disclosure.

FIG. 11 is a diagram illustrating query results during a testing process according to an embodiment of the disclosure.

FIG. 12 is a schematic illustration of a comparison of test ranges for embodiments of the present disclosure.

Fig. 13 is a schematic diagram of a testing segment of an application of an embodiment of the present disclosure.

Fig. 14 is a block diagram of a test apparatus according to an embodiment of the present disclosure.

Detailed Description

Technical solutions in the embodiments of the present disclosure will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present disclosure, and it is apparent that the described embodiments are only a part of the embodiments of the present disclosure, and not all the embodiments of the present disclosure. All other embodiments, which can be derived by a person skilled in the art from the embodiments disclosed herein without making any creative effort, shall fall within the protection scope of the present disclosure.

The containerization technology is a kernel lightweight operating system layer virtualization technology. The container is used for packaging the application and the operation environment of the application in a container mode, and the application and the operation environment are packaged into a light, portable and self-contained container.

With the rapid development of business, the container is continuously optimized in an iteration mode. Containers involve a large number of pages and components. Each optimization of a container is closely related to the upper layer service. Therefore, when the components in the container are modified, the pages of the container need to be tested.

For the test mode, in general, one is to establish a mapping relationship between a code and a test case by interpolating a stub in an APP, thereby implementing an accurate test. However, this approach is not usable in the technical architecture of the dynamic container and is intrusive to code. And the other method is that the influence range of the component change cannot be determined, so that a full regression test is carried out on all the pages. However, this method has a large testing range and low testing efficiency.

In order to solve the above problems, the embodiments of the present disclosure provide a method for accurately positioning a page range affected by a component to be tested in a testing process, and only the affected page needs to be tested, so that the number of tested pages is reduced, and the testing efficiency is improved.

Referring to fig. 1, a flow chart of steps of a testing method of an embodiment of the present disclosure is shown.

As shown in fig. 1, the testing method may include the steps of:

step 101, aiming at a component to be tested in a container to be tested, screening out a target page which refers to the component to be tested, and taking the target page as a page to be tested.

The component to be tested refers to the component that is subject to alteration. For example, a property of a component is modified, a method of a component is modified, and so on.

Considering that in an actual business scenario, any one component may only be referred to by a part of pages, if the component is changed, the component actually only needs to be tested on the page referring to the component, and other pages not referring to the component do not need to be tested. Therefore, in the embodiment of the present disclosure, for the components to be tested in the container to be tested, the target page that refers to the components to be tested may be screened out first, and the target page is taken as the page to be tested. Specific procedures will be described in detail in the following examples.

And 102, jumping to the page to be tested, and testing the page to be tested.

After the page to be tested which refers to the component to be tested is obtained through screening, the page to be tested can be jumped to and tested, so that the function of the page to be tested after referring to the component to be tested can be tested. Specific procedures will be described in detail in the following examples.

In implementations, any one component may be referenced by one or more pages, and any one page may reference one or more components. In this embodiment, the number of components to be tested may be one or more, and the number of target pages referencing any one of the components to be tested may be one or more. The above steps 101 to 102 may represent a process for any one of the components to be tested.

In the embodiment of the disclosure, considering that the modified to-be-tested component may be only referred to by a part of pages, the page range affected by the to-be-tested component is accurately positioned in the testing process, and the to-be-tested page is screened out, so that only the to-be-tested page needs to be tested, the number of tested pages can be reduced, and the testing efficiency is improved.

Alternatively, the container mentioned in the embodiments of the present disclosure may include, but is not limited to, a dynamic container.

The dynamic container is a high-performance cross-platform dynamic framework, and can achieve a high-performance page rendering target through a simple and efficient framework. The method realizes high-performance dynamic capability and also integrates the high-performance dynamic capability into a service development code system in the form of dynamic pages, dynamic modules and even dynamic views with stronger adaptive capability. The dynamic container may include, but is not limited to: picaso, rn (read native), Flutter, Weex, and the like. Pages developed using dynamic containers have a very wide range of applications. Pages of the dynamic container application include, but are not limited to: a food detail page, a food channel page, a scenery spot detail page, a merchant detail page, a hotel detail page, a personal detail page, a collection page, a free try page, a topical topic page, a user comment page, and the like.

In the embodiment of the disclosure, aiming at the problem that the influence range of each component change cannot be determined in the dynamic container test, so that the test efficiency is low, the effect of accurately positioning the influence range is achieved by means of component structured information extraction and page reference analysis and a depth chain technology.

For clarity of description, the following description will take the example of the dynamic container Picasso. Picaso is a cross-platform high-performance dynamic container, and supports multi-end operation of iOS, Android (Android), webpage (Web) and the like by using TypeScript (TypeScript is a free and open-source programming language developed by microsoft) as a development language.

Referring to fig. 2, an overall frame diagram of an embodiment of the present disclosure is shown. As shown in fig. 2, the overall process may include, but is not limited to: data reporting, data storage and data query. Each of these parts will be described below.

1. Data reporting

The data reporting process may include, but is not limited to: analyzing component information, analyzing page reference, and dynamically reporting and analyzing a jump protocol use case (Scheme). The following are introduced separately.

1.1 component information parsing

The component information parsing process is used to analyze which components are contained in the dynamic container in total and which attributes each component has.

Optionally, the component information parsing process may specifically include: and carrying out document analysis on the source codes corresponding to the components in the container to be tested, and extracting the names and the attributes of the components.

Optionally, document parsing is performed on the source code corresponding to the component in the container to be tested, and the process of extracting the name and the attribute of each component may include: converting a source code corresponding to a component in the container to be tested into a document tree in a JavaScript Object Notation (JSON) format; and searching a node representing the component name from the document tree, and searching a node representing the component attribute corresponding to the component name from the child node of the node representing the component name to obtain the name and the attribute of each component.

The following is a detailed description.

As shown in fig. 2, the component information parsing may include: the method comprises the steps of Node Package Manager (NPM) Package standardization, component standardization and component structural information extraction. After component attribute information (including component names, component attributes and the like) is obtained through a component information analysis process, data is dynamically reported in an NPM packaging process so as to be convenient for data storage.

The NPM package represents the source code corresponding to the components in the container to be tested, and one NPM package can contain information of a plurality of components. Because the NPM packet may have multiple sources, and the format of the NPM packet code may be different under different sources, the NPM packet may be standardized according to a preset standard format of the NPM packet. Similarly, since the component may have multiple sources, and the format of the component code may be different from source to source, the component may be standardized according to a predetermined set of standard formats. For the specific process of standardization, the present embodiment will not be discussed in detail here.

After the NPM packet is standardized and the components are standardized, component structured information extraction is carried out. The structured information of the component may include, but is not limited to: the name of the component, the properties of the component (the properties of the component may contain property type and property name), and so on.

Referring to fig. 3, a schematic diagram of a component information parsing process according to an embodiment of the present disclosure is shown.

As shown in fig. 3, the component information parsing process may include: and analyzing the NPM component information by utilizing a document generation tool (TypeDoc) aiming at the NPM package source code, specifically performing bridge extraction, view component extraction and structured information extraction, and finally obtaining component structured information.

The process shown in FIG. 3 is implemented by TypeDoc. The TypeDoc is a document generation tool for Typescript projects, and information can be extracted and analyzed from an NPM package by means of basic capability of the TypeDoc.

For the standardized NPM package, information such as all components and attributes/methods of the components in one NPM package can be analyzed by means of TypeDoc, and further component structural information can be obtained.

TypeDoc can translate a series of TypeScript code into a document tree in JSON format.

As shown in FIG. 4, the nodes of the document tree exist in different types, which may include but are not limited to: class (Class), Function (Function), Enumeration (Enumeration), Interface (Interface), etc.

According to the types, a certain degree of basic classification can be performed on the components contained in one NPM packet, so as to obtain nodes (not shown in fig. 4) representing component names under each type. In an implementation, view components often correspond to classes (classes) or interfaces (interfaces), and bridge components often correspond to functions (functions). For example, in FIG. 4, a Class (Class) may include a paginated view (ViewPager) component, a View Filter (FilterView) component, a grid View (GridView) component, and the like; the Function (Function) may include a store () method, a retrieve () method, and so on; enumeration (Enumeration) may include paging view direction (viewpagedirection), etc.; an Interface (Interface) may include a code log (CodeLogger) component, and the like. A plurality of nodes (not shown in FIG. 4) representing attributes of the components may also be included under each component in the document tree. And further drilling down for the information of each component to obtain the attribute type and the attribute name of the component.

And analyzing all the components in the NPM package by adopting the method to finally obtain the structural information of each component.

Fig. 5 is a schematic diagram of a component information parsing result according to an embodiment of the present disclosure. It is understood that the analysis result shown in fig. 5 is only for illustration and is not a limitation to the embodiment.

As shown in fig. 5, after the NPM package is analyzed, the component types contained therein are obtained as a view component and a bridge component.

The component names under the component type view component include a paginated view (ViewPager) component, a grid view (GridView) component, and the like. The Property types under the component name pagination view (ViewPager) component include Constructor (Constructor), Property (Property), Accessor (Accessor), Object declaration (Object Literal), Method (Method), and so on. An attribute name (not shown in fig. 5) may be included under each attribute type. For example, the attribute name (method name) under the Constructor (Constructor) in fig. 5 may include ViewPager () or the like; the attribute name under the attribute (Property) may include an item count (ItemCount), an auto carousel (AutoPlay), and the like; the attribute name under the Accessor (Accessor) may include a command reference (CommandRef), a click (onClick), etc.; the attribute name under the Object declaration (Object Literal) may include a pagepagecode controller (PageControlFrame), etc.; the attribute name (Method name) under the Method (Method) may include info (), addPageView (), and the like.

The component names under the component type bridge component include a pop-up box (Popover) component, a mobile-side network interface (MAPI) component, and the like. The attribute types under the component name pop-up (Popover) component include functions (functions), and the like, and an attribute name (not shown in fig. 5) may be included under each attribute type. For example, the attribute name (method name) under the Function (Function) in fig. 5 may include show (), hide (), isPopoverShow (), and the like.

1.2, Page reference analysis

The page reference analysis process is used to analyze which pages each component and attribute is referenced by.

Optionally, the page reference analysis process may include: and analyzing a grammatical structure of a source code corresponding to the page in the container to be tested based on the name and the attribute of each component, and extracting the name and the attribute of the component quoted by each page.

Optionally, the process of performing syntax structure analysis on the source code corresponding to the page in the container to be tested based on the name and the attribute of each component, and extracting the name and the attribute of the component referred by each page may include:

converting a source code corresponding to a page in the container to be tested into an abstract syntax tree;

extracting the names of source codes corresponding to the components introduced by the abstract syntax tree and the names of the components based on a preset first syntax rule; the first syntax rule represents the name of a source code corresponding to the component introduced by the abstract syntax tree and a rule which needs to be met by the name of the component;

extracting a variable name corresponding to the instantiated component object of the abstract syntax tree based on a preset second syntax rule; the second syntax rule represents a rule which needs to be satisfied by a variable name corresponding to a component object instantiated by the abstract syntax tree;

extracting the attribute of the instantiated component of the abstract syntax tree based on a preset third syntax rule; the third syntax rule represents a rule that the attribute of the component instantiated in the abstract syntax tree needs to satisfy, and the third syntax rule is set based on the variable name and the name and attribute of each component.

The following is a detailed description.

As shown in FIG. 2, the page reference analysis may include: abstract syntax tree conversion, dynamic container analyzer packaging and component reference analysis. After page reference information (including page identification, names and attributes of page referenced components and the like) is obtained through a page reference analysis process, data is dynamically reported when pages are packed so as to store the data.

The page reference analysis is to obtain which components are used in the current source code and which attributes of the components are used by the TypeScript source code in combination with the component structural information. The business code of picaso is developed based on the TypeScript language, and then the page reference analysis takes the TypeScript source code as a core.

As shown in FIG. 6, the page reference analysis process may include: aiming at a page source code (namely a TypeScript source code), combining the obtained component structural information, executing an Abstract Syntax Tree (AST) conversion process, a dynamic container Analyzer (Picasso Analyzer) packaging process, an analysis process (specifically including Import (Import) analysis, variable analysis and reference analysis), and finally obtaining an analysis result.

TypeScript AST conversion: the abstract syntax tree of TypeScript can express the structure and information of a TypeScript statement, and the page reference analysis is performed based on AST.

The TypeScript language has a corresponding abstract syntax tree. The ts file may be parsed into a unique AST, or an AST may be translated into a unique TypeScript source code file.

Each statement in the TypeScript source code corresponds to a sub-tree in the AST.

Take a statement of const listView, viewwithframe (0,115,120,140), which corresponds to a sub-tree in AST.

Each node in the AST contains syntax information of the corresponding sentence, and each node also has its own type. For example, the type of the root node is "VariableStatement", indicating that this statement is used to express a variable declaration. Meanwhile, each node can drill down the child nodes further, and finally, the complete expression of one statement can be obtained.

Therefore, the logic expressed by each TypeScript statement can be obtained by traversing the AST, and the expected grammar information can be extracted.

Picaso Analyzer package: the AST in the original TypeScript language contains much syntax information, which complicates syntax analysis. For better AST analysis, a Picasso Analyzer is packaged on top of the native TypeScript AST to analyze the syntactic structure of the TypeScript source code, thereby extracting component reference information.

Picaso Analyzer syntax rules: the grammar rules define grammar conditions that are satisfied by an AST "node".

Still taking the statement of const listView, view within frame (0,115,120,140) as an example, it is desired to extract the name of a variable initialized by list view. According to this scenario, a grammar rule can be set:

1) the current node is VariableDeclaration and its child node initializer is CallExpression;

2) the child node expression of CallExpression is propertyaccesdexpression;

3) the child node expression of PropertyAccessExpression is ListView and the child node name is viewWithFrame.

If the current node meets the above rule, the child node name of the current node is the name of the variable to be extracted, which is ListView in this example.

The picaso Analyzer actually defines a series of grammar rules, and if a certain node in the AST satisfies the grammar rules, necessary information in the node is extracted.

Design advantages of picaso Analyzer syntax rules: the complex AST traversal process is hidden, and only the grammar rules corresponding to the nodes need to be concerned. The expansibility is enhanced, and any form of grammar rule can be defined and added into the rule set.

The analysis process comprises the following steps: the analysis process is divided into Import analysis, variable analysis and reference analysis.

Imort analysis: and extracting the NPM introduced by the current file and the corresponding component.

Taking the statement import { VC, BaseView, ListView, ListItem, View } from "@ dp/picaso" as an example, the statement corresponds to a sub-tree in AST.

According to this scenario, a grammar rule can be set:

1) the current node is importDeclaration, the child node modelSpecifier of the current node is importClause, and the child node nameBindings of the importClause is not null;

2) if the rules are satisfied, the child node modelprovider of the current node is the name of the NPM packet, and all child nodes in namebindings of the child node importclass are all components introduced by the NPM packet.

This obtains the set of a series of components that the current file introduces (import).

And (3) variable analysis: and extracting the variable name corresponding to the component object instantiated by the current file.

Taking a statement of private myllistview ═ new ListView () as an example, the statement corresponds to a sub-tree in AST.

According to this scenario, a grammar rule can be set:

1) the current node is a NewExpression, the name of the child node exppression represents the class name of the component corresponding to the variable, and the current example is ListView;

2) the parent node of the current node is PropertyDeclaration, VariableDeclaration or BinaryExpression, the name of the child node name of the parent node is the name of the variable to be acquired, the parent node under the current example is PropertyDeclaration, and the variable name is MyListView.

For statements that meet the above rules, the name of the current variable and what the component type corresponding to the variable is can be obtained, and in the current example, myListView is known to be a variable and its type is a ListView component.

Citation analysis: and extracting information such as the used attribute and method according to the component variable name of the current file.

The components introduced in a source code file are obtained through the first two stages, and the corresponding variable names are instantiated by the components, and then the attributes and the methods used by the components are easily extracted.

Take the statement mylistview, section count 2 as an example, which corresponds to a sub-tree in AST.

According to this scenario, a grammar rule can be set:

1) the current node is PropertyAccess expression;

2) the child node expression is a variable name, and the variable exists in a previously extracted variable name set;

3) its child node name is the attribute or method name referenced by the variable, and the attribute or method exists in the structured information of the corresponding component.

For statements that meet the above rules, the attribute or method referenced by a variable can be obtained, and in the present example, it can be known that the sectionCount attribute of ListView is used by myListView.

It can be seen that each step of the above analysis process actually defines a series of grammar rules, and the nodes meeting the grammar rules in the AST are the reference information to be extracted.

Fig. 7 is a schematic diagram of a page reference analysis result according to an embodiment of the present disclosure. As shown in fig. 7, after analyzing the TypeScript source code, the component names that can be referred to by the page 1 (such as the page picasso-point-mail) include: a text view (TextView) component, an image view (ImageView) component, a mobile edge network interface (MAPI) component, a paginated view (ViewPager) component, and the like.

The Property types under the component name text view (TextView) component include Property (Property), Method (Method), and the like. An attribute name (not shown in fig. 7) may be included under the attribute type. For example, the Property names under the Property (Property) in fig. 7 may include text display mode (TextModel), transparency (Alpha), click (onClick), and the like; the attribute name (Method name) under the Method (Method) may include SizeToFit () or the like.

The Property type under the component name image view (ImageView) component includes a Property (Property) and the like. An attribute name (not shown in fig. 7) may be included under the attribute type. For example, the Property name under the Property (Property) in fig. 7 may include a picture address (ImageUrl), a picture scaling mode (ImageScale), a command reference (CommandRef), a picture display mode (ContentMode), and the like.

The attribute types under the component name mobile terminal network interface (MAPI) component include a Method (Method), and the like. An attribute name (not shown in fig. 7) may be included under the attribute type. For example, the attribute name (Method name) under the Method (Method) in fig. 7 may include fetch () or the like.

The Property types under the component name pagination view (ViewPager) component include Property (Property), and the like. An attribute name (not shown in fig. 7) may be included under the attribute type. For example, the Property name under the Property (Property) in fig. 7 may include an item count (ItemCount), an item layout (layout), and the like.

1.3 Scheme dynamic reporting analysis

When the Picasso page is tested, the target page is entered in the APP according to the specified path, and the page path is deep, so that a great amount of time is needed for communicating with the specific path of the business party. For the problem, the depth chain technology is adopted in the embodiment, the depth chain technology can skip the middle page, the page is directly opened through the page Scheme, and the method is fast and accurate. The Scheme is an APP internal page jump protocol, each page corresponds to one Scheme, and the corresponding page can be directly opened through the Scheme. Therefore, only one full amount of Scheme (namely, a jump protocol case) needs to be maintained, and during each test, the Scheme is used for directly opening the corresponding page for testing.

In addition, since the picaso pages are updated iteratively, there are often new pages added or dropped pages, and in order to improve the testing efficiency and testing effectiveness, the entire amount of Scheme needs to be dynamically updated and kept consistent with the data on the line.

Optionally, the skip protocol use case dynamic reporting analysis process may include: receiving page information reported by a client, wherein the page information comprises a page identifier and a jump protocol use case corresponding to a page; extracting page information corresponding to an effective page from the page information reported by the client; and creating the second mapping relation based on the page information corresponding to the effective page.

The following is a detailed description.

As shown in fig. 2, the Scheme dynamic reporting analysis process may include: and the client collects and reports, filters invalid data and performs data deduplication processing. After the page Scheme is obtained through the Scheme dynamic reporting analysis process, data are reported dynamically when the APP opens the dynamic page, so that data storage can be carried out conveniently.

As shown in fig. 8, first, a client collects and reports. In the process of collecting and reporting by a client, opening any dynamic page by an APP internal test packet, entering a debugging panel, reporting a jump protocol case (Scheme) corresponding to the page, and performing database dropping. Then a valid Scheme extraction was performed. And in the effective Scheme extraction process, performing test page filtering, invalid Scheme filtering and data deduplication on the Scheme reported by the client. The test page filtering refers to filtering Scheme corresponding to some test pages for testing. The invalid schema filtering refers to filtering the schemes corresponding to invalid pages (such as counterfeit pages and the like) which are not actually used by the APP. The data deduplication refers to deduplication processing of Scheme corresponding to the same page.

2. Data storage

As shown in fig. 2, in the data storage portion, based on the component attribute information reported after the component information analysis and the page reference information reported after the page reference analysis process, a mapping relationship between the page and the components referred by the page may be created. This embodiment refers to this mapping relationship as a first mapping relationship, and a specific implementation form of the first mapping relationship may be a mapping relationship between a page identifier and a name and an attribute of a component referred by a page. Based on the page reference information reported after the page reference analysis process and the page Scheme reported by the Scheme dynamic report analysis, a mapping relation between the page and the corresponding Scheme can be established. In this embodiment, the mapping relationship is referred to as a second mapping relationship, and a specific implementation form of the second mapping relationship may be a mapping relationship between a page identifier and a Scheme identifier corresponding to a page.

FIG. 9 is a schematic diagram of a data storage portion of an embodiment of the present disclosure. As shown in fig. 9, through data reporting, the structural information, the page reference relationship, and the full page schema of the component are obtained respectively. And then reporting the core data to a database and establishing a mapping relation. And finally acquiring the mapping relation among the components, the attributes and the pages and Scheme corresponding to the pages.

3. Data query

After the first mapping relation between the page and the components quoted by the page and the second mapping relation between the page and the jump protocol case are obtained, relevant information can be inquired based on the corresponding mapping relation in the testing process. As shown in fig. 2, in the data query process, a tester may trigger a query instruction through a front-end query page, and the system queries the mapping relationship stored in the data storage portion through the query interface in response to the query instruction.

Specifically, in the testing process, the process of screening out the target page that refers to the component to be tested may include: and inquiring a target page which refers to the to-be-tested component based on a first mapping relation which is created in advance.

Specifically, in the testing process, the process of jumping to the page to be tested may include: inquiring a target jump protocol case corresponding to the page to be tested based on a second mapping relation established in advance; and jumping to the page to be tested through the target jumping protocol.

Hereinafter, the technical effects of the embodiments of the present disclosure will be described by way of examples.

(1) The component structural information and the page reference information of the dynamic container can be accurately acquired.

FIG. 10 is a schematic diagram of a component and page analysis results of an embodiment of the present disclosure. As shown in fig. 10 by way of example, the detailed information of the pageview (ViewPager) component is obtained by the precision test system according to the embodiment of the present disclosure. The ViewPager component has 79 attributes in total, specifically, automatic carousel (AutoPlay), page turning Direction (Direction), circular page turning (circular scrollable), disabled manual sliding (Disablescroll), whether to display dots (Schowpagecontrol), sliding resilience (scrollpoint), automatic carousel time interval (AutoPlay interval), and the like, as shown in fig. 10. The ViewPager component is used by 40 pages in total, specifically, as shown in fig. 10, a food channel page, a free try page, a food detail page, a sight details page, and the like.

(2) The mapping relation between the components and the attributes and the page is established, and after a certain component and attribute are modified, the influence range can be accurately retrieved.

FIG. 11 is a diagram illustrating query results during a testing process according to an embodiment of the disclosure. As shown by way of example in fig. 11, by means of the assembly: paginated view (ViewPager) and attributes: the sliding resilience capability (scrollbackness) is retrieved, and the scrollbackness attribute of the ViewPager component is used by 5 picaso pages in total, specifically, a food detail page, a scenery detail page, and the like shown in fig. 11, and 5 jump protocol use cases (Scheme) corresponding to the 5 pages are obtained.

(3) The test efficiency is greatly improved.

FIG. 12 is a schematic illustration of a comparison of test ranges for embodiments of the present disclosure. As shown in the example of fig. 12, again taking the component ViewPager and the property ScrollSource as an example, a version optimizes the ScrollSource capability. Before the precision test system of the embodiment of the disclosure is not used, the whole number of pages needs to be tested, and the number is 300 +. After the accurate test system disclosed by the embodiment of the disclosure is adopted for retrieval, the number of pages to be tested is 5, specifically, the page using the sliding resilience (Scrollbource) attribute of the paging view (ViewPager) component, and the test efficiency is improved by 98%.

The test method of the embodiment of the disclosure can be applied to each test link. Fig. 13 is a schematic diagram of a testing segment of an application of an embodiment of the present disclosure. As shown in fig. 13 by way of example, the method may be used in various links such as development self-test, access test for test engineers, and automation test.

In the development self-testing process, a requirement related page is retrieved through an accurate testing system, testing covers a core page, and then page regression testing and component case testing are carried out. In the process of access testing of a test engineer, a requirement related page is retrieved through an accurate testing system, all pages are covered by testing, and then page regression testing and component case testing are carried out. In the automatic test process, a requirement related page (small test range, frequent and rapid test and richer test items) is retrieved through an accurate test system, a jump protocol case (Scheme) traversal test is carried out, and pull-down refreshing, page operation, normal page display and whether breakdown exist are related. And (3) performing skip protocol case (Scheme) traversal pocket bottom test (wide test range, once pocket bottom every day) on the full skip protocol case (Scheme), relating to normal page display and whether breakdown exists. The specific testing procedures are not discussed in detail herein.

Referring to fig. 14, a block diagram of a test apparatus according to an embodiment of the present disclosure is shown.

As shown in fig. 14, the test apparatus may include the following modules:

a screening module 1401, configured to screen out, for a component to be tested in a container to be tested, a target page that refers to the component to be tested, and use the target page as a page to be tested;

the testing module 1402 is configured to jump to the page to be tested, and test the page to be tested.

Optionally, the screening module 1401 is specifically configured to query a target page referencing the component to be tested based on a pre-created first mapping relationship; wherein the first mapping relationship represents a mapping relationship between a page and a component referenced by the page.

Optionally, the test module 1402 is specifically configured to query, based on a second mapping relationship created in advance, a target jump protocol case corresponding to the page to be tested; the second mapping relation represents the mapping relation between the page and the jump protocol use case; and jumping to the page to be tested through the target jumping protocol.

For the device embodiment, since it is basically similar to the method embodiment, the description is simple, and for the relevant points, refer to the partial description of the method embodiment.

In an embodiment of the present disclosure, an electronic device is also provided. The electronic device may include one or more processors, and one or more computer-readable storage media having instructions, such as an application program, stored thereon. The instructions, when executed by the one or more processors, cause the processors to perform a testing method as any one of the embodiments above.

In an embodiment of the present disclosure, there is also provided a non-transitory computer readable storage medium having stored thereon a computer program executable by a processor of an electronic device, the computer program, when executed by the processor, causing the processor to perform a testing method as described in any of the above embodiments.

The aforementioned processor may be a general-purpose processor, and may include but is not limited to: a Central Processing Unit (CPU), a Network Processor (NP), a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA) or other Programmable logic device, a discrete Gate or transistor logic device, a discrete hardware component, and so on.

The above-mentioned computer-readable storage media may include, but are not limited to: read Only Memory (ROM), Random Access Memory (RAM), Compact Disc Read Only Memory (CD-ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), hard disk, floppy disk, flash Memory, and the like.

The algorithms and displays presented herein are not inherently related to any particular computer, virtual machine, or other apparatus. Various general purpose systems may also be used with the teachings herein. The required structure for constructing such a system will be apparent from the description above. In addition, embodiments of the present disclosure are not directed to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of the embodiments of the present disclosure as described herein, and any descriptions of specific languages are provided above to disclose the best modes of the embodiments of the present disclosure.

In the description provided herein, numerous specific details are set forth. However, it is understood that embodiments of the disclosure may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure an understanding of this description.

Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the disclosure, various features of the embodiments of the disclosure are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the disclosure and aiding in the understanding of one or more of the various inventive aspects. However, the disclosed method should not be interpreted as reflecting an intention that: that is, claimed embodiments of the disclosure require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive aspects lie in less than all features of a single foregoing disclosed embodiment. Thus, the claims following the detailed description are hereby expressly incorporated into this detailed description, with each claim standing on its own as a separate embodiment of an embodiment of this disclosure.

Those skilled in the art will appreciate that the modules in the device in an embodiment may be adaptively changed and disposed in one or more devices different from the embodiment. The modules or units or components of the embodiments may be combined into one module or unit or component, and furthermore they may be divided into a plurality of sub-modules or sub-units or sub-components. All of the features disclosed in this specification (including any accompanying claims, abstract and drawings), and all of the processes or elements of any method or apparatus so disclosed, may be combined in any combination, except combinations where at least some of such features and/or processes or elements are mutually exclusive. Each feature disclosed in this specification (including any accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise.

The various component embodiments of the disclosure may be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. It will be understood by those skilled in the art that a microprocessor or Digital Signal Processor (DSP) may be used in practice to implement some or all of the functions of some or all of the components in a motion picture generating device according to an embodiment of the present disclosure. Embodiments of the present disclosure may also be implemented as an apparatus or device program for performing a portion or all of the methods described herein. Such programs implementing embodiments of the present disclosure may be stored on a computer readable medium or may be in the form of one or more signals. Such a signal may be downloaded from an internet website or provided on a carrier signal or in any other form.

It should be noted that the above-mentioned embodiments illustrate rather than limit embodiments of the disclosure, and that those skilled in the art will be able to design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. Embodiments of the disclosure may be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means may be embodied by one and the same item of hardware. The usage of the words first, second and third, etcetera do not indicate any ordering. These words may be interpreted as names.

It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

The above description is only a specific implementation of the embodiments of the present disclosure, but the scope of the embodiments of the present disclosure is not limited thereto, and any person skilled in the art can easily conceive of changes or substitutions within the technical scope of the embodiments of the present disclosure, and all the changes or substitutions should be covered by the scope of the embodiments of the present disclosure.

Claims

1. a test method, is characterized in that, comprises:

For the component to be tested in the container to be tested, filter out the target page referencing the component to be tested, and use the target page as the page to be tested;

Jump to the page to be tested, and test the page to be tested.

2. The method according to claim 1, wherein the filtering out the target page referencing the component to be tested comprises:

Based on the pre-created first mapping relationship, query the target page referencing the component to be tested;

The first mapping relationship represents a mapping relationship between a page and a component referenced by the page.

3. The method according to claim 2, wherein the first mapping relationship is created in the following manner:

Perform document parsing on the source code corresponding to the component in the container to be tested, and extract the name and attribute of each component;

Based on the names and attributes of the components, perform syntax structure analysis on the source code corresponding to the pages in the container to be tested, and extract the names and attributes of the components referenced by the pages;

The first mapping relationship is created based on the names and attributes of the components referenced by the respective pages.

4. The method according to claim 3, wherein the document parsing is performed on the source code corresponding to the component in the container to be tested, and the names and attributes of each component are extracted, comprising:

Convert the source code corresponding to the component in the container to be tested into a document tree in JSON format;

Find the node representing the component name in the document tree, and find the node representing the component attribute corresponding to the component name from the child nodes of the node representing the component name, to obtain the name and attribute of each component.

5. The method according to claim 3, wherein, based on the name and attribute of each component, the source code corresponding to the page in the container to be tested is parsed, and the source code referenced by each page is extracted. The name and properties of the component, including:

Convert the source code corresponding to the page in the container to be tested into an abstract syntax tree;

The name of the source code corresponding to the component introduced by the abstract syntax tree and the name of the component are extracted based on the preset first syntax rule; the first syntax rule represents the name of the source code corresponding to the component introduced by the abstract syntax tree and the rules that the name of the component needs to satisfy;

The variable name corresponding to the component object instantiated by the abstract syntax tree is extracted based on a preset second grammar rule; the second grammar rule indicates the rule that the variable name corresponding to the component object instantiated by the abstract syntax tree needs to satisfy ;

The attribute of the component instantiated by the abstract syntax tree is extracted based on a preset third grammar rule; the third grammar rule indicates the rule that the attribute of the component instantiated by the abstract syntax tree needs to satisfy, and the third grammar Rules are set based on the variable names and the names and properties of the components.

6. The method according to claim 1, wherein the jumping to the page to be tested comprises:

Based on a pre-created second mapping relationship, query the target jump protocol use case corresponding to the page to be tested; wherein, the second mapping relationship represents the mapping relationship between the page and the jump protocol use case;

Jump to the page to be tested through the target jump protocol use case.

7. The method according to claim 6, wherein the second mapping relationship is created in the following manner:

Receive page information reported by the client, where the page information includes a page identifier and a jump protocol use case corresponding to the page;

Extract the page information corresponding to the valid page from the page information reported by the client;

The second mapping relationship is created based on page information corresponding to the valid page.

8. A test device, characterized in that, comprising:

A screening module, configured to screen out a target page referencing the component to be tested for the component to be tested in the container to be tested, and use the target page as the page to be tested;

A test module, configured to jump to the page to be tested, and test the page to be tested.

9. An electronic device, characterized in that, comprising:

one or more processors; and

one or more computer-readable storage media having instructions stored thereon;

The instructions, when executed by the one or more processors, cause the processors to perform a testing method as claimed in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that a computer program is stored thereon, and when the computer program is executed by a processor, the processor is made to execute the method according to any one of claims 1 to 7. testing method.