Methods, computer software products and data processing systems for automated testing of transactional applications via web service interfaces
Web service components facilitate automated testing of transactional applications by enabling data exchange and regression testing, addressing the challenge of testing back-end systems without user interfaces.
Patent Information
- Application Number
- DE112012004499
- Authority / Receiving Office
- DE · DE
- Patent Type
- Patents
- Current Assignee / Owner
- Priority Date
- 2012-04-13
- Filing Date
- 2012-10-17
- Publication Date
- 2024-12-05
- Estimated Expiration
- Not applicable · inactive patent
AI Technical Summary
Testing back-end transaction systems, such as banking and securities trading systems, is challenging due to the lack of user interfaces, making it difficult to exchange test data and perform adequate testing without developing cumbersome front-end applications.
Utilizing web service components to facilitate data exchange between a test application and a transactional application, enabling regression testing through an application program interface, and generating web service components based on the transactional application interface to support automated testing.
Enables efficient and automated testing of transactional applications by bypassing the need for complex front-end scaffolding, ensuring thorough regression testing and improved testing efficiency.
Smart Images

Figure 00000000_0000_ABST
Abstract
Description
BACKGROUND OF THE INVENTION
[0001] Transaction systems, including, for example, banking and / or securities trading systems, may include back-end applications that execute logic that may be required to complete transactions. A front end to these systems may be developed for presentation and ease of use and may allow one or more users to enter information. The front end of these systems may call one or more back-end applications to execute the logic to complete the transaction. In certain situations, testing these back-end systems can be difficult because there may be no user interface through which to access them.
[0002] CN 1 996 375 A describes a method and apparatus for performing transaction tests in a host environment. SUMMARY OF THE INVENTION
[0003] The invention is described by the features of the independent claims. Embodiments are specified in the dependent claims.
[0004] In one embodiment, a method may include importing, via one or more computing devices, one or more web service components configured to at least partially exchange test data between a test application and a transactional application. The test application may be configured at least partially to test the transactional application. The method may further include testing the transactional application, via the one or more computing devices, using at least partially the one or more web service components to exchange test data between the test application and the transactional application.
[0005] One or more of the following features may be included. The one or more web service components may further be configured to exchange test data between the test application and a transactional application interface. The transactional application interface may be configured to enable, at least in part, data exchange with the transactional application. The method may further include defining one or more input parameters and one or more return parameters for the transactional application interface via at least in part the one or more web service components. Testing the transactional application may further include receiving test data via at least in part the one or more web service components.Testing the transaction application may further include passing the test data to the transaction application through at least part of the transaction application interface.
[0006] In one implementation, the method may include exporting a transactional application interface configured to facilitate, at least in part, data transfer to a software development application via the transactional application. The method may further include generating the one or more web service components via at least in part the software development application based at least in part on the transactional application interface. The transactional application interface may be an application program interface associated with the transactional application. The test application may be configured to, at least in part, regression test functionality on the transactional application. The method may further include receiving input test data via at least in part the one or more web service components from the test application.The method further includes sending result test data via at least in part the one or more web service components to the test application.
[0007] In one embodiment, a computer program product may be embodied on a computer-readable storage medium, and a plurality of instructions may be stored thereon. When executed by a processor, the instructions may cause the processor to perform operations, e.g., importing, via one or more computing devices, one or more web service components configured to exchange test data between a test application and a transactional application. The test application may be configured to at least partially test the transactional application. The operations may further include testing the transactional application, via the one or more computing devices, using, at least in part, the one or more web service components to exchange test data between the test application and the transactional application.
[0008] One or more of the following features may be included. The one or more web service components may be further configured to exchange test data between the test application and a transactional application interface. The transactional application interface may be configured to enable, at least in part, an exchange of data with the transactional application. The operations may further include defining, through at least in part, one or more input parameters and one or more return parameters for the transactional application interface via the one or more web service components. Testing the transactional application may further include receiving test data via the one or more web service components.Testing the transaction application may further include passing the test data to the transaction application via at least partially the transaction application interface.
[0009] In one implementation, the operations may include exporting a transaction application interface configured to enable, at least in part, data transfer via at least in part the transaction application with a software development application. The operations may further include generating the one or more web service components via at least in part the software development application based at least in part on the transaction application interface. The transaction application interface may be an application program interface associated with the transaction application. The test application may be configured to, at least in part, regression test functionality on the transaction application.The operations may further include receiving input test data from the test application via at least in part the one or more web service components. The operations may further include sending result test data to the test application via at least in part the one or more web service components.
[0010] In one embodiment, a data processing system is provided. The data processing system may include at least one processor and at least one memory architecture coupled to the at least one processor. The data processing system may further include a first software module executable by the at least one processor and the at least one memory architecture, wherein the first software module may be configured to import one or more web service components configured to, at least in part, exchange test data between a test application and a transactional application. The test application may be configured, at least in part, to test the transactional application.Furthermore, the data processing system may include a second software module that may be configured to test the transaction application at least in part using the one or more web service components to exchange test data between the test application and the transaction application.
[0011] One or more of the following features may be included. The one or more web service components may be further configured to exchange test data between the test application and a transactional application interface. The transactional application interface may be configured to enable, at least in part, data exchange with the transactional application. A third software module may be configured to define one or more input parameters and one or more return parameters for the transactional application interface via at least in part the one or more web service components. The second software module may be further configured to receive, at least in part, test data via at least in part the one or more web service components.Furthermore, the second software module may be further configured to forward at least some of the test data to the transaction application via at least some of the transaction application interface.
[0012] In one implementation, a fourth software module may be configured to export a transaction application interface configured to enable, at least in part, data transfer via the transaction application to a software development application. A fifth software module may be configured to generate the one or more web service components via at least in part the software development application based at least in part on the transaction application interface. The transaction application interface may be an application program interface associated with the transaction application. The test application may be configured to, at least in part, regression test functionality on the transaction application.A sixth software module may be configured to receive input test data from the test application via at least some of the one or more web service components. A seventh software module may be configured to send result test data to the test application via at least some of the one or more web service components.
[0013] In one embodiment, a method may include importing one or more web service components configured to at least partially exchange test data between an application for performing regression testing of the functionality and a transactional application program interface via the one or more computing devices. The application for performing regression testing of the functionality may be configured at least in part to test a test application configured to exchange data with other software applications via at least in part the transactional application program interface.The method may further include testing the transactional application via the one or more computing devices using at least in part the one or more web service components to exchange test data between the application for performing regression testing of the functionality and the transactional application program interface.
[0014] Details of one or more implementations are set forth in the accompanying drawings and the description below. Other features and advantages will become apparent from the description, drawings, and claims. BRIEF DESCRIPTION OF THE MULTIPLE VIEWS OF THE DRAWINGS Fig. Figure 1 is a schematic view of a transaction application testing process connected to a distributed computing network. Fig. 2 is a flowchart of the transaction application testing process of Fig. 1; Fig. 3 is a schematic flowchart related to the transaction application testing process of Fig. 1 belongs; Fig. 4 is also a schematic flowchart related to the transaction application testing process of Fig. 1 belongs; Fig. Figure 5 is also a schematic flowchart related to the transaction application testing process of Fig. 1 belongs; Fig. 6 is also a schematic flowchart related to the transaction application testing process of Fig. 1 belongs; Fig. Figure 7 is also a schematic flowchart related to the transaction application testing process of Fig. 1 belongs; and Fig. Figure 8 is a flowchart of a transaction application testing process. DETAILED DESCRIPTION OF THE INVENTION
[0015] With reference to the Fig. 1 and Fig. 2, a transactional application testing process 10 is shown. As discussed below, the transactional application testing process 10 may import 100 one or more web service components configured to at least partially exchange test data between a test application and a transactional application. The test application may be configured to at least partially test the transactional application. The transactional application testing process 10 may also test the transactional application using at least partially the one or more web service components 102 to exchange test data between the test application and the transactional application.
[0016] The transaction application test (TAT) process may be a server-side process (e.g., a server-side TAT process 10), a client-side process (e.g., a client-side TAT process 12, a client-side TAT process 14, a client-side TAT process 16, or a client-side TAT process 18), or a server-side / client-side hybrid process (e.g., the combination of the server-side TAT process 10 and one or more of the client-side TAT processes 12, 14, 16, 18).
[0017] The server-side TAT process 10 may be located on and executed by a server computer 20, which may be connected to a network 22 (e.g., the Internet or a local area network). Examples of the server computer 20 may include (but are not limited to): a personal computer, a server computer, a series of server computers, a minicomputer, and / or a mainframe computer. The server computer 20 may be a web server (or series of servers) running on a network operating system, examples of which may include (but are not limited to): Microsoft Windows Server; Novell Netware; or Red Hat Linux.
[0018] The instruction sets and subroutines of a server-side TAT process 10, which may be stored on a storage device 24 connected to the server computer 20, may be executed by one or more processors (not shown) and one or more memory architectures (not shown) integrated into the server computer 20. The storage device 24 may include (but is not limited to): a hard disk drive; a tape drive; an optical drive; a RAID array; random access memory (RAM); and read-only memory (ROM).
[0019] The server computer 20 may execute a web server application, examples of which include (but are not limited to): Microsoft IIS, Novell Web Server, or Apache Web Server, which provides access to the server computer 20 (over a network 22) using one or more protocols, examples of which may include, but are not limited to, HTTP (i.e., HyperText Transfer Protocol), SIP (i.e., Session Initiation Protocol), and the Lotus® Sametime® VP protocol. The network 22 may be connected to one or more secondary networks (e.g., network 26), examples of which may include (but are not limited to): a local area network; a wide area network; or an intranet.
[0020] The client-side TAT processes 12, 14, 16, 18 may reside on the electronic client devices 28, 30, 32, and 34, respectively, examples of which may include, but are not limited to, a personal computer 28, a laptop computer 30, a data-capable mobile phone 32, a notebook computer 34, a personal digital assistant (not shown), a smartphone (not shown), and a dedicated network device (not shown). The electronic client devices 28, 30, 32, 34 may each be connected to the network 22 and / or the network 26 and may each execute an operating system, examples of which may include, but are not limited to, Microsoft Windows, Microsoft Windows CE, Red Hat Linux, or a custom operating system.
[0021] The instruction sets and subroutines of the client-side TAT processes 12, 14, 16, 18, which may be stored on the storage devices 36, 38, 40, and 42, respectively, connected to the electronic client devices 28, 30, 32, and 34, respectively, may be executed by one or more processors (not shown) and one or more storage architectures (not shown) integrated into the electronic client devices 28, 30, 32, and 34, respectively. Storage devices 36, 38, 40, and 42 may include (but are not limited to): hard disk drives; tape drives; optical drives; RAID arrays; random access memory (RAM); read-only memory (ROM); compact flash (CF) storage devices; secure digital (SD) storage devices; and memory stick storage devices.
[0022] The client-side TAT processes 12, 14, 16, 18 and / or the server-side TAT process 10 may be processes that execute within (i.e., are part of) a software development platform (e.g., IBM® Rational® Software Development Platform). Alternatively, the client-side TAT processes 12, 14, 16, 18 and / or the server-side TAT process 10 may be stand-alone applications associated with the software development platform. One or more of the client-side TAT processes 12, 14, 16, 18 and the server-side TAT process 10 may communicate with each other (via the network 22 and / or the network 26). The TAT process 10 may also execute within any software development application and / or software testing application.
[0023] Users 44, 46, 48, 50 can directly access the server-side TAT process 10 via the device on which the client-side TAT process (e.g., the client-side TAT processes 12, 14, 16, 18) is executed, namely, for example, the electronic client devices 28, 30, 32, 34. The users 44, 46, 48, 50 can directly access the server-side TAT process 10 via the network 22 and / or the secondary network 26. Furthermore, the server computer 20 (i.e., the computer executing the server-side TAT process 10) can be connected to the network 22 via the secondary network 26, as represented by the notional link line 52.
[0024] The various electronic client devices may be connected directly or indirectly to the network 22 (or the network 26). For example, the personal computer 28 is shown connected directly to the network 22 via a hard-wired network connection. Furthermore, the notebook computer 34 is shown connected directly to the network 26 via a hard-wired network connection. The laptop computer 30 is shown wirelessly connected to the network 22 via a wireless transmission channel 54 established between the laptop computer 30 and a wireless network access point (i.e., WAP) 56, which is shown connected directly to the network 22. The WAP 56 may, for example, be an IEEE 802.11a, 802.11b, 802.11g, 802.11n, Wi-Fi and / or Bluetooth device capable of establishing a wireless transmission channel 54 between the laptop computer 30 and the WAP 56.The data-capable mobile telephone 32 is shown wirelessly connected to the network 22 via a wireless transmission channel 58 that is established between the data-capable mobile telephone 32 and a mobile network / mobile bridge 60 that is shown directly connected to the network 22.
[0025] As is well known in the art, all IEEE 802.11x specifications can use the Ethernet protocol and carrier sensing multiple access with collision avoidance (i.e., CSMA / TAT) for path sharing. For example, the various 802.11x specifications can use phase-shift keying (PSK) or complementary code keying (CCK) modulation. As is well known in the art, Bluetooth is a telecommunications industry specification that allows mobile phones, computers, and personal digital assistants to be interconnected using a short-range wireless connection. THE TRANSACTION APPLICATION TESTING (TAT) PROCESS
[0026] In the following discussion, the server-side TAT process 10 is described for illustrative purposes. It should be noted that the client-side TAT process 12 may interact with the server-side TAT process 10 and may be executed within one or more applications that enable data communication with the client-side TAT process 12. However, this is not intended to limit the present disclosure, as other configurations are possible (e.g., standalone client-side TAT processes and / or standalone server-side TAT processes). For example, some implementations may include one or more of the client-side TAT processes 12, 14, 16, 18 instead of, or in addition to, the server-side TAT process 10.It should be noted that one or more of the operations of the TAT processes discussed herein may be performed solely by one of the plurality of TAT processes, solely by one or more of a transaction application, a test application, and a software development application, or by a combination of one or more of the TAT processes and one or more of the transaction application, the test application, and the software development application.
[0027] Back-end systems of transactional applications that execute logic required to perform transactions (e.g., banking transactions, securities trading transactions, etc.) may not have interfaces through which they are accessible to testers. In certain situations, testers can develop front-end applications for the specific purpose of testing those back-end applications. These front-end applications are sometimes referred to as scaffolding and can allow testers to exchange test data with the back-end applications. Sometimes this leads to inadequate testing of the back-end applications or no testing at all. Adequate testing may be easier to achieve if testers can avoid developing front-end applications for the specific purpose of testing.
[0028] For example, transaction applications can be executed in a transaction server without user terminal interaction (e.g., without interaction with a user). One or more transactions can be communicated via an application program interface with other components (e.g., calling programs 718 in Fig. 7) interact to send data parameters to and from the program. This type of application architecture allows business and user-specific functional requirements to be separated from information presentation and control, where appropriate. Since there is no user terminal interface, these transactional applications can be difficult to test. Testing these transactional applications can be made easier for developers by incorporating one or more of the following: a transactional application program interface (e.g., a transaction application interface), web service definitions (e.g., web service artifacts and / or components), a web service development application and / or tools (e.g., a software development application), and an automated functional testing tool (e.g., a test application).
[0029] It will now Fig. 3, for example, a transaction application 300 (e.g., a business application, banking application, and / or securities trading application), which may include a back-end application, may receive input test data 302 from a test application 304 during testing and send result test data 306 back to a test application 304. The result test data 302 may be the output of the transaction application 300 after the transaction application 300 processes the input test data 302. The test application 300 may, for example, be a functional testing tool and may perform a regression test of functionality on the transaction application 300. A regression test of functionality may be a test configured to find errors after changes are made to an application.As discussed above, when the transactional application 300 includes one or more back-end applications, it may be difficult to pass the input test data 302 to the transactional application 300 and receive the result test data 306 from the transactional application 300 without developing scaffolding for testing.
[0030] It will now also be Fig. 4, in which the transaction application 300 may have an associated transaction application interface 408 during normal operation. The transaction application interface 408 may provide a set of rules and / or specifications that other software programs must follow to exchange data with the transaction application interface 408. In operation, the transaction application 300 may be invoked by a transaction call 404. The transaction application interface 408 may receive input data 402 from the transaction call 404 and may forward the input data 402 to the transaction application 300. The transaction application 300 may perform operations on the input data 402 and forward output data 406 back to the transaction call 404 via the transaction application interface 408.In this way, the transaction application interface 408 can be used to pass data to and receive data from the transaction application 300. In some situations, the transaction application interface 408 can be used to pass test data to and receive result data from the transaction application 300 to facilitate testing.
[0031] Furthermore, the transaction application interface can be used to create, derive, or generate one or more web service artifacts and / or components. A web service can be a software system designed to support computer interaction over a network. A web service definition language can be a language for describing functionality provided by a web service and can describe how one or more web services can be invoked, can describe the parameters of the web services, and so on. The one or more web service components can be used to pass test data to and receive result data from the transaction application 300 to facilitate testing.Additionally, in some situations, the one or more web service components may be used in conjunction with the transactional application interface to pass test data to and receive result data from the transactional application 300 to facilitate testing.
[0032] It will now also be on the Fig. 1 and Fig. 5, in which the TAT process 10 may import 100 one or more web service components (e.g., web service components 502, 504) configured to at least partially exchange test data (e.g., input test data 302, result test data 306) between the test application 304 and the transactional application 300. The test application 304 may be configured to at least partially test the transactional application 300. Furthermore, the TAT process 10 may test 102 the transactional application 300 using at least in part one or more web service components (e.g., web service components 502, 504) to exchange test data (e.g., input test data 302, result test data 306) between the test application 304 and the transactional application 300.
[0033] It will now also be Fig. 6, in which the one or more web service components (e.g., web service components 502, 504) may be further configured (104) to exchange test data (e.g., input test data 302, result test data 306) between the test application 304 and the transaction application interface 408. The transaction application interface 408 may be configured to, at least in part, enable an exchange of data with the transaction application 300. For example, the transaction application interface 408 may be a set of rules and / or specifications that enable other software programs to exchange data with the transaction application 300. In one embodiment, the TAT process 10 may be implemented at least in part via one or more web service components (e.g.,Web service components 502, 504) define 106 one or more input parameters and one or more return parameters for the transaction application interface 408. These input parameters and return parameters may be configured according to the rules and / or specifications of the transaction application interface 408 to enable one or more web service components (e.g., web service components 502, 504) to communicate with the transaction application 300.
[0034] Continuing with the example, the above TAT process 10 may receive 108 test data (e.g., input test data 302) via at least in part the one or more web service components (e.g., web service component 502). The result test data 306 may be received at the transaction application interface 408. Furthermore, the TAT process 10 may forward 110 test data (e.g., input test data 302) to the transaction application 300 via at least in part the transaction application interface 408.
[0035] In one embodiment and now also with reference to Fig. 7, the TAT process 10 may export 112 a transaction application interface 708 configured to facilitate, at least in part, data transfer with a transaction application 702 to a software development application 706. The TAT process 10 may import the transaction application interface 708 into the software development application 706. The software development application 706 may be a web service development application and support the creation of a web service. Furthermore, the TAT process 10 may be configured in conjunction with the software application development 706 to extract the transaction application interface 708 and import it for use in creating one or more web service components.
[0036] For example, the TAT process 10 may generate 114 one or more web service components (e.g., web service component 720) via at least in part the software development application 706 based at least in part on the transaction application interface 708. The transaction application interface 708 may be an application program interface associated with the transaction application 300 (116). When generating a web service component 720, the TAT process 10 may implement the web service component 720 in conjunction with the service development application 706. The web service component 720 may be implemented on the transaction application 702 or one or more computing devices executing the transaction application 702.In this way, the TAT process 10 can use an application program interface associated with the transaction application 300 to form a web service interface, thus facilitating regression testing of the transaction application 300.
[0037] In one embodiment, the TAT process 10, in conjunction with the software development application 706, may create and / or generate a web service definition language associated with the web services and / or web service components used to communicate with the transactional application interface 708. As noted above, a web service definition language may be a language for describing functionality provided by a web service, and may describe how one or more web services may be invoked, may describe the parameters of the web services, and so on. The TAT process 10 may export the web service definition language in conjunction with the software development application 706 to a test application 704. Furthermore, the TAT process 10 may import the web service definition language in conjunction with the test application 704.
[0038] The test application 704 may be configured to at least partially test the transaction application 702. Furthermore, the test application 704 may be configured (118) to at least partially perform a regression test of the functionality on the transaction application 702. As mentioned above, regression tests of the functionality may be used to find new defects after changes are made to an application. In one embodiment, the test application 704 may be configured to perform an automatic regression test of the functionality. In other words, the test application 704 may automatically perform regression test cases on the transaction application 702.
[0039] The TAT process 10, in conjunction with the transaction application 702, may receive 120 input test data (e.g., input test data 712) from the test application 704 via at least in part the one or more web service components (e.g., web service component 720). Furthermore, the TAT process 10 may use the input test data 712 to execute the transaction application 702, which may then output result test data 714. Furthermore, the TAT process 10 may send 122 the result test data 714 to the test application 704 via at least in part the one or more web service components (e.g., web service component 720).
[0040] The test application 704 can support web service testing and script creation functionality. Furthermore, the test application 704 can include a regression testing tool. The regression testing tool can use the web service definition to record an activity script using one or more predefined parameters to compare the result set data 714 with one or more predefined predicted values. In this way, the success of testing the transaction application 702 can be determined, and appropriate changes can be made if necessary.
[0041] For example, the user of a test application may use a functional test tool included in the test application 704 to record a test session using one or more input and return parameters that may be defined by the transactional application interface. The user of the test application may import the web service definition language to create a web service functional test and create a data pool of input test data for the transactional application along with predicted results. The functional test tool may step through the transactional application and record each step and result. Once the steps are fully performed, the user of the functional test tool may save the recorded session as a script for further testing. In this way, a data pool (e.g.Data pool 716) for the one or more input and return parameters and the predicted results for the functional testing tool based at least in part on the above script. The user of the functional testing tool can then execute the recorded script using the data in the data pool to test the transactional application.
[0042] The functional testing tool can exchange data with the web service component associated with the transaction application using a Simple Object Access Protocol (SOAP) and / or TCP / IP protocol, and can perform a functional test of the transaction application using the web service. The web service component (e.g., web service component 720) associated with the transaction application (e.g., transaction application 702) can invoke and exchange data with the transaction application via the transaction application interface, which in turn can be an application program interface.
[0043] Once the transaction application has been executed with the input test data (e.g., input test data 712 from the data pool 716), it may return the results (e.g., result set data 712) to the web service component 720 via the transaction application interface 708. The web service component 720 may send the results back to the functional test tool (e.g., associated with the test application 704). The functional test tool may compare the results with the predicted results that may be stored in the data pool. The results may then be reported to the user by the functional test tool.
[0044] It will now also be Fig.8, in one embodiment, the TAT process 10 may import 100 one or more web service components (e.g., web service components 720) configured to at least partially exchange test data (e.g., input test data 712, result test data 714) between a functionality regression testing application (e.g., test application 704) and a transactional application program interface (e.g., transactional application interface 708). The functionality regression testing application (e.g., test application 704) may be configured at least in part to test the transactional application 702. The transactional application 702 may be configured to exchange data with other software applications via at least in part the transactional application program interface 708.Furthermore, the TAT process 10 may test 802 the transaction application 702 using at least in part the one or more web service components (e.g., web service components 720) to exchange test data (e.g., input test data 712, result test data 714) between the application 704 for performing regression testing of the functionality and the transaction application program interface 708.
[0045] As will be understood by those skilled in the art, aspects of the present invention may be embodied in the form of a system, apparatus, method, or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, microcode, etc.), or an embodiment combining software and hardware aspects, all of which may be generally referred to herein as a "circuit," "module," or "system." Furthermore, aspects of the present invention may take the form of a computer program product embodied as one or more computer-readable media having computer-readable program code.
[0046] Any combination of one or more computer-readable media may be used. The computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or unit, or any suitable combination of the foregoing.More specific examples (non-exhaustive list) of the computer-readable storage medium include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM) or flash memory, an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer-readable storage medium may be any tangible medium that can contain or store a program for use by, or in connection with, an instruction execution system, apparatus, or device.
[0047] A computer-readable signal medium may include a propagating data signal having computer-readable program code, for example, in baseband or as part of a carrier wave. Such a propagating signal may take a variety of forms, such as, but not limited to, electromagnetic, optical, or any suitable combination thereof. A computer-readable signal medium may be any computer-readable medium, other than a computer-readable storage medium, that can transmit, carry, or transport a program for use by, or in connection with, an instruction-execution system, apparatus, or device.
[0048] The program code embodied in a computer-readable medium may be transmitted using any suitable medium, such as, but not limited to, wireless, wired, fiber optic cable, RF, etc., or a combination of the foregoing.
[0049] Computer program code for performing operations for aspects of the present invention may be written in any combination of one or more programming languages, for example, an object-oriented programming language such as Java, Smalltalk, C++, or the like, and conventional procedural programming languages such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer (i.e., an electronic client device), partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on the remote computer or server (i.e., a server computer).In the latter scenario, the remote computer can be connected to the user's computer via any type of network, such as a local area network (LAN) or a wide area network (WAN), or the connection can be made to an external computer (e.g., via an Internet service provider over the Internet).
[0050] Aspects of the present invention may be described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and / or computer program products according to embodiments of the invention. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, may be implemented by computer program instructions.These computer program instructions may be provided to a processor of a general purpose computer, a specific computer, or other programmable data processing device to produce a machine, such that the instructions, executing via the processor of the computer or other programmable data processing device, create means for implementing the functions / acts specified in the one or more flowchart and / or block diagram blocks.
[0051] These computer program instructions may also be stored in a computer-readable medium that can instruct a computer, other programmable data processing apparatus, or other devices to operate in a particular manner such that the instructions stored in the computer-readable medium produce an article of manufacture that includes instructions that implement the function / action specified in the one or more flowchart and / or block diagram blocks.
[0052] The computer program instructions may also be loaded into a computer, other programmable data processing device, or other devices to cause a series of operational steps to be performed in the computer, on the other programmable device, or on other devices to produce a computer-implemented method, such that the instructions executing on the computer or on the other programmable device provide methods for implementing the functions / acts specified in the one or more flowchart and / or block diagram blocks.
[0053] The flowcharts and block diagrams in the figures may illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block of the flowchart or block diagrams may represent a module, segment, or portion of code comprising one or more executable instructions for implementing the one or more specified logical functions. It should also be noted that in some alternative implementations, the functions identified in the blocks may occur in a different order than shown in the figures. For example, two consecutive blocks may actually execute substantially concurrently, or the blocks may sometimes execute in reverse order, depending on functionality.Furthermore, one or more blocks shown in the block diagrams and / or flowchart illustrations may not be performed in some implementations or may not be required in some implementations. It should also be noted that each block of the block diagrams and / or flowchart illustrations, and combinations of blocks in the block diagrams and / or flowchart illustrations, may be implemented by specific hardware-based systems that perform the specified functions or actions or combinations of specific hardware and computer instructions.
[0054] Various embodiments and implementations have been described. Nevertheless, it will be understood that various changes may be made. Accordingly, other embodiments and implementations are within the scope of the following claims.
Claims
[1] Method comprising: Importing, via one or more computing devices, one or more web service components configured to at least partially exchange test data between a test application and a transactional application, wherein the test application is at least partially configured to test the transactional application; Creating a web service interface via the one or more computing devices using an application program interface associated with the transactional application to facilitate regression testing of the transactional application; Exporting a transaction application interface of the transaction application, the transaction application interface configured to enable, at least in part, data transfer with the transaction application to a software development application; Creating the one or more web service components via at least in part the software development application based at least in part on the transactional application interface, creating a web service definition language associated with the web service components and used to communicate with the transactional application interface; Recording an activity script across the one or more computing devices using one or more predefined parameters to generate a data pool of one or more input parameters, one or more return parameters, and predicted results; Saving the activity script via the one or more computing units as a recorded session for further automated testing; automatically testing the transaction application via the one or more computing devices using at least in part the stored activity script and the one or more web service components to exchange test data between the test application and the transaction application, and executing the recorded script to use the data pool to automatically test the transaction application; Receiving input test data at least in part via a first web service component of the one or more web service components from the test application; Transferring result test data at least partially via a second web service component of the one or more web service components to the test application; and Comparing the results of testing the transaction application with the expected results from the data pool across the one or more data processing units. [2] The method of claim 1, wherein the one or more web service components are further configured to exchange test data between the test application and a transaction application interface configured to at least partially enable an exchange of data with the transaction application. [3] The method of claim 2, further comprising: Defining the one or more input parameters and the one or more multiple return parameters for the transaction application interface across at least partially the one or more web service components. [4] The method of claim 2, wherein testing the transaction application further comprises: Receiving test data via at least part of the one or more web service components; and Passing the test data to the transaction application via at least part of the transaction application interface. [5] The method of claim 2, wherein the transaction application interface is an application program interface associated with the transaction application. [6] The method of claim 1, wherein the test application is at least partially configured to perform a regression test of the functionality on the transaction application. [7] Method comprising: Importing, via the one or more computing devices, one or more web service components configured to at least partially exchange test data between a transactional application program interface and an application for performing regression testing of the functionality, wherein the test application is at least partially configured to test the transactional application configured to exchange data with other software applications at least partially via the transactional application program interface; Creating a web service interface via the one or more computing devices using a transaction application program interface associated with the transaction application to facilitate regression testing of the transaction application; Exporting a transaction application interface of the transaction application, the transaction application interface configured to enable, at least in part, data transfer with the transaction application to a software development application; Creating the one or more web service components via at least in part the software development application based at least in part on the transactional application interface, creating a web service definition language associated with the web service components and used to communicate with the transactional application interface; Recording an activity script across the one or more computing devices using one or more predefined parameters to generate a data pool of one or more input parameters, one or more return parameters, and predicted results; Saving the activity script via the one or more computing units as a recorded session for further automated testing; automatically testing the transaction application via the one or more computing devices using at least in part the stored activity script and the one or more web service components to exchange test data between the transaction application program interface and the application for performing regression testing of the functionality, and Run the recorded script to use the data pool to automatically test the transaction application; Receiving input test data at least in part via a first web service component of the one or more web service components from the test application; Transferring result test data at least partially via a second web service component of the one or more web service components to the test application; and Comparing the results of testing the transaction application with the expected results from the data pool across the one or more data processing units. [8] A computer program product residing on a computer-readable storage medium having stored thereon a plurality of applications which, when executed by a processor, cause the processor to perform operations comprising: Importing, via one or more computing devices, one or more web service components configured to at least partially exchange test data between a test application and a transactional application, wherein the test application is at least partially configured to test the transactional application; and Creating a web service interface via the one or more computing devices using an application program interface associated with the transactional application to facilitate regression testing of the transactional application; Exporting a transaction application interface of the transaction application, the transaction application interface configured to enable, at least in part, data transfer with the transaction application to a software development application; Creating the one or more web service components via at least in part the software development application based at least in part on the transactional application interface, creating a web service definition language associated with the web service components and used to communicate with the transactional application interface; Recording an activity script across the one or more computing devices using one or more predefined parameters to generate a data pool of one or more input parameters, one or more return parameters, and predicted results; Saving the activity script via the one or more computing units as a recorded session for further testing; automatically testing the transaction application via the one or more computing devices using at least in part the stored activity script and the one or more web service components to exchange test data between the test application and the transaction application; Receiving input test data at least in part via a first web service component of the one or more web service components from the test application; Transferring result test data at least partially via a second web service component of the one or more web service components to the test application; and Comparing the results of testing the transaction application with the expected results from the data pool across the one or more data processing units. [9] The computer program product of claim 8, wherein the one or more web service components are further configured to exchange test data between the test application and a transaction application interface configured to at least partially enable an exchange of data with the transaction application. [10] The computer program product of claim 9, wherein the operations further comprise: Defining one or more input parameters and one or more return parameters for the transactional application interface through at least in part the one or more web service components. [11] The computer program product of claim 9, wherein testing the transaction application further comprises: Receiving test data via at least part of the one or more web service components; and Passing the test data to the transaction application via at least part of the transaction application interface. [12] The computer program product of claim 9, wherein the transaction application interface is the application program interface associated with the transaction application. [13] The computer program product of claim 8, wherein the test application is at least partially configured to perform a regression test of the functionality on the transaction application. [14] Data processing system comprising: at least one processor; at least one memory architecture connected to the at least one processor; a first software module executable by the at least one processor and the at least one memory architecture, the first software module configured to import one or more web service components configured to at least partially exchange test data between a test application and a transaction application, the test application configured at least partially to test the transaction application; a second software module executable by the at least one processor and the at least one memory architecture, wherein the second software module is configured to generate a web service interface using an application program interface associated with the transaction application to facilitate regression testing of the transaction application, wherein the second software module is further configured to record an activity script using one or more predefined parameters to generate a data pool of one or more input parameters, one or more return parameters, and predicted results, wherein the second software module is further configured to store the activity script as a recorded session for further testing, wherein the second software module is further configuredthat it automatically tests the transaction application using at least in part the stored activity script and the one or more web service components to exchange test data between the test application and the transaction application, wherein the second software module is further configured to compare results of testing the transaction application with the expected results from the data pool; a fourth software module executable by the at least one processor and the at least one memory architecture, the fourth software module configured to export a transaction application interface of the transaction application, the transaction application interface configured to at least partially enable data transfer with the transaction application to a software development application; a fifth software module executable by the at least one processor and the at least one memory architecture, wherein the fifth software module is configured to generate the one or more web service components via at least in part the software development application based at least in part on the transaction application interface, and wherein a web service definition language is generated that is associated with the web service components and that is used to exchange data with the transaction application interface; a sixth software module executable by the at least one processor and the at least one memory architecture, the sixth software module configured to receive input test data from the test application at least in part via a first web service component of the one or more web service components; and a seventh software module executable by the at least one processor and the at least one memory architecture, the seventh software module configured to transmit result test data to the test application at least in part via a second web service component of the one or more web service components. [15] The data processing system of claim 14, wherein the one or more web service components are further configured to exchange test data between the test application and a transaction application interface configured to at least partially enable an exchange of data with the transaction application. [16] The data processing system of claim 15, further comprising: a third software module executable by the at least one processor and the at least one memory architecture, the third software module configured to define one or more input parameters and one or more return parameters for the transaction application interface via at least in part the one or more web service components. [17] The data processing system of claim 15, wherein the fifth software module is further configured to partially: Receiving test data via at least part of the one or more web service components; and Passing the test data to the transaction application via at least part of the transaction application interface. [18] The data processing system of claim 15, wherein the transaction application interface is an application program interface associated with the transaction application. [19] The data processing system of claim 14, wherein the test application is at least partially configured to perform a regression test of the functionality on the transaction application.
Citation Information
Patent Citations
Method and device for implementing transaction test in host environment
CN1996375A
CN000001996375A
