WO2002033553A1

WO2002033553A1 - Http request generation from xml definitions

Info

Publication number: WO2002033553A1
Application number: PCT/IB2000/001493
Authority: WO
Inventors: Samu Paajanen
Original assignee: Nokia Corporation; Nokia Inc.
Priority date: 2000-10-17
Filing date: 2000-10-17
Publication date: 2002-04-25
Also published as: AU2000276801A1

Abstract

An HTTP request generator automatically generates an HTTP request based on an XML description. The HTTP request is sent to a server. The server receives the HTTP request and responds to the HTTP request. The HTTP request can be used to test operation of the server. The server can serve a file in response to the HTTP request. The HTTP request generator can be employed in a client/server architecture. The HTTP request generator can augment a browser running on a client computer. A computer system for implementing the invention is disclosed.

Description

TITLE HTTP REQUEST GENERATION FROM XML DEFINITIONS

TECHNICAL FIELD This invention relates generally to application design and coding, and more particularly to an HTTP request generator and method for automatically generating HTTP requests based on XML definitions.

BACKGROUND ART The Internet, a particular computer network, is a worldwide interconnection of computers, or servers, in business, academic and commercial use. The Internet provides its users with access to vast amounts of information and resources. The World Wide Web ("the Web") is the portion of the Internet that allows the presentation and exchange of information in a graphical format providing representations of graphical and photographic data in addition to textual information. A significant reason for the dramatic growth in the use of the Web is the standardization and use of a common communications protocol for the presentation and exchange of information on the Web. The use of a common communications protocol allows almost anyone with a computer to connect to, and interact with the Web, regardless of the type of computer hardware and software an individual computer might employ. The standard protocol of the Web is known as hypertext transfer protocol ("HTTP").

The Web accounts for a significant part of the growth in the popularity of the Internet, perhaps because of the user-friendly graphical user interfaces of browsers that are readily available for accessing the Web The Web makes hypertext documents available to users over the Internet A hypertext document does not present information linearly like a book, but instead provides the reader with links or pointers to other locations so that the user may jump from one location to another The hypertext documents on the Web are accessed through the client/server protocol of HTTP

The basic unit of HTTP communications is the "message" Messages are exchanged between clients and servers A server or "Web server" is an application program that accepts connections from clients and other servers in order to receive request messages from clients and, in response, deliver response messages to the requesting client

A Web server services two types of requests file-object requests and gateway requests A file-object request is a request from a client for the server to deliver a file-object, which resides at a location locally accessible to the server, to the client A gateway request is a request from a client for a resource that does not reside in the file system In the case of a gateway request, the Web server acts as an intermediary between the client and another application

With reference to FIG 1 , a typical network system includes a network server 100 The network server 100 has resident therein a file system 102, CGI scripts 104, and a Web site (an HTML-based program) 106 CGI (Common Gateway Interface) is a programming language typically used to send database queries and results back and forth on the Internet CGI scripts include programs that run on an Internet server and allow clients to submit identification information, request data, and otherwise interact with databases stored on the server A first personal computer 1 10 is communicatively coupled to the network server 100 in a node-to-server Internet connection. The first personal computer 110 runs a browser 112, which allows the first personal computer 110 to submit information, request data, and interact with the Web site 106 and file system 102 stored on the network server 100.

A second personal computer 114 is communicatively coupled to the network server 100 in a node-to-server Internet connection. The second personal computer 114 runs a browser 116, which allows the second personal computer 114 to submit information, request data, and interact with the Web site 106 and file system 102 stored on the network server 100.

The first personal computer 110 and the second personal computer 114 are communicatively coupled in a node-to-node Internet connection.

The Web site 108 shown in FIG. 1 is physically located within the network server 102. Alternatively, such a system can operate on any network that links two or more clients and is not limited to the Internet. For example, the system could be set up on a local-area-network (LAN). In such a case, an HTML-based program would still be running on the server to coordinate activity, but since the network is not on the Internet, the HTML-based program would not be called a Web site (since it is not on the Web). The success of a Web site can be attributed not only to its content and functionality but also to the server used to power it. A Web server serves static content to a Web browser at a basic level. In other words, the Web server receives a request for a Web page such as: "http://www.mindmeld.com/index.html", and maps that Uniform Resource Locator (URL) to a local file on the server. In this case, the file "index.html" is somewhere on the file system. The server then loads this file from disk and serves it out across the network to the user's Web browser. This entire exchange is mediated by the browser and server talking to each other using HTTP. FIG. 2 schematically illustrates this workflow among a browser, a network server, and a file system. Referring to FIG. 2, in step 202, a user of the browser requests a document (e.g., "index.html"). In step 204, the network server looks for the document on the file system. In step 206, the network server retrieves the document from the file system. In step 208, the network server returns the document to the browser. This arrangement, which allows the serving of static content such as HTML and image files to a Web browser, was the initial concept behind the World Wide Web, and has led to more complex information exchanges being possible between browsers and Web servers.

DISCLOSURE OF THE INVENTION

According to an exemplary embodiment of the invention, a network includes a server and a client computer communicatively coupled to the server. An HTTP request generator on the client computer automatically generates an HTTP request based on an XML description. The HTTP request generator sends the HTTP request to the server. The server receives the HTTP request and responds to the HTTP request generator. The HTTP request can be used to test operation of the server. The server can send a file to the HTTP request generator in response to the HTTP request. The HTTP request generator can augment or include a browser running on the client computer. Other aspects and advantages of the invention will become apparent from the following detailed description and accompanying drawings, illustrating by way of example the features of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a network that includes a server computer and client computers;

FIG. 2 illustrates a flow of a request and a response among a browser, a network server, and a file system; FIG. 3 illustrates a personal computer;

FIG. 4 is a schematic view of an HTTP request generator; FIG. 5 is a flow diagram depicting a process of generating an HTTP request; and

FIG. 6 illustrates an example computer system for implementing the invention.

BEST MODE(S) FOR CARRYING OUT THE INVENTION The preferred embodiment is discussed in detail below. While specific steps, configurations and arrangements are discussed, it should be understood that this is done for illustrative purposes only. A person skilled in the relevant art will recognize that other steps, configurations and arrangements can be used without departing from the spirit and scope of the invention.

For a better understanding of the invention, together with other and further objects, advantages, and capabilities thereof, reference is made to the following disclosure and drawing figures. For clarity of explanation, the illustrative embodiments of the present invention are presented as comprising individual functional blocks. The functions these blocks represent may be provided through the use of either shared or dedicated hardware, including, but not limited to, hardware capable of executing software. For example, the functions of the blocks presented in FIGS. 4 and 5 may be provided by a single shared processor. Illustrative examples may comprise digital signal processor (DSP) hardware, read-only memory (ROM) for storing software performing the operations discussed below, and random-access memory (RAM) for storing DSP results. Very large scale integration (VLSI) hardware embodiments, as well as custom VLSI circuitry in combination with a general purpose DSP circuit, may also be provided.

FIG. 3 illustrates a personal computer 302. The personal computer 302 includes a display 304, a central processing unit 306 having an associated internal memory, a keyboard 308, and a mouse 310. A main window 312 appears on the display 304 when the personal computer is operated. Using the mouse 310 and keyboard 308, a user can select an HTTP request generator program to run on the computer. The HTTP request generator program automatically generates (or allows the user to manually generate) an HTTP request from an XML ("extensible Markup Language") file stored, for example, in the memory associated with the CPU 306. A window 314 for the HTTP request generator program appears within the main window 312 on the display 304. One or more electronic files 316, 318 can be represented by an icon in the displayed indow 314. The User opens an electronic file by double clicking the icon that is associated with the electronic file using the mouse 310. In accordance with the principles of the invention, HTTP requests can be automatically created from an XML definition. XML is an open standard defined by the World Wide Web Consortium (W3C). XML is an open architecture for application development and a globally accepted specification for exchanging complex structured data. XML was designed to provide a metalanguage standard that could be used to describe metadata. XML is more flexible than the HTML language; and features can be added transparently to an application written in XML code, as compared to an application written in HTML code.

Referring again to FIG. 3, when the user double-clicks the icon 316 for the XML file using the mouse 310, the HTTP generator program operates to make an HTTP request that corresponds to the XML file, and operates to store that HTTP request as an HTTP file (which is represented by its own icon 318) in the memory associated with the CPU 306 of the personal computer 302, in accordance with the principles of the invention. FIG. 4 illustrates an architecture for the HTTP request generator. Referring to

FIG. 4, the HTTP generator 402 receives an XML file 404, created, for example, by a user at a personal computer. Responsive to input of the XML file 404, the HTTP generator 402 produces an HTTP request 406 based on the XML file 404.

The HTTP request generator 402 has a front-end component 408 and a back- end component 410. The front-end compiler component 408 processes XML files into an internal representation known as a parse tree 412. The back-end compiler component 410 processes the parse tree 412 into the HTTP request 406.

FIG. 5 is a process flow diagram depicting a process of generating an HTTP request in accordance with the principles of the invention. In the specific embodiment illustrated in FIG. 5, the process is executed by the HTTP request generator 402 (FIG. 4). An example of the structure of the HTTP request generator 402 is discussed in detail below with respect to FIG. 6.

Referring to FIG. 5, in box 502, the user creates an XML definition. In box 504, a processor executes instructions to generate an XML file based on the XML description. In box 506, the compiler front-end processes the XML file into a parse tree. In box 508, the compiler back-end processes the parse tree into an HTTP request.

A variety of tags are used in the XML description. A tag is a marker that identifies what the data are which are associated with the tag, and may be composed of a character string enclosed in special characters, reserved words, or other syntax that distinguishes the tag from associated data. "Special characters" typically refer to characters other than letters and numbers, which are defined and reserved for use with tags. Special characters are used so that a parser processing the data stream will recognize that this a tag. A tag is normally inserted preceding its associated data; a corresponding tag may also be inserted following the data, to clearly identify where that data end.

According to the invention, during the process of generating HTTP requests, the parameters, the targets of the requests, etc. can all be given in human-readable XML format in the XML description, which can easily be parsed by different tools. The XML presentation can, for example, be converted to a Java object. It is therefore a relatively straightforward task to build an automatic tester program, which simply generates based on XML descriptions HTTP requests to the server and analyses the responses received from the server. The process of generating an HTTP request from an XML description has the following advantages: Requests are specified in human-readable form; test cases can be generated directly from the specification; and test cases can easily be converted to other formats. The process of generating an HTTP request has numerous applications. The process facilitates an automatic testing tool, in which test cases for the server software can be generated automatically from the XML definition. A test program (which can be implemented, for example, as a Java application, or Java applet that talks to a Java servlet using RMl or HTTP) reads the file(s) containing request definitions in XML format, and then emulates the terminal device (or a human user) by generating HTTP requests according to the request definition(s).

The process facilitates a request recorder. A user having problems with his terminal device could call to the operator's help service. The operator, using the management interface, could turn on the recording, which records all the requests originating from the selected user's device in XML format. The operator could then try to solve the problem by investigating the recorded data or automatically rerunning the requests.

The process facilitates an error handler. A server can save all the requests which cannot be served in the special error log in XML format. The operator can then investigate the recorded requests or try to re-run them with an automatic test tool.

The process facilitates saving the requests for safety. Sometimes a user may commit operations, which must be recorded for safety. For example, it might be a good idea to record all the requests in which the users need to send their credit card number along with the HTTP request.

The process facilitates undoing operations. An undo-operation is something that few, if any, Web applications support. If a reverse operation for every undoable request is defined, an undo operation can be implemented. By saving the "n" reverse operations in XML format, the undo operation for the "n" most recent operations can be implemented. If the user, for example, adds a new object into his favorite link list, the terminal generates the delete-request and saves it into the terminal's undo-list. Alternatively, the undo-list can be saved into the server, and the operations can later be undone by the user or by the operator upon the user's request.

An example XML description, which can be used to generate an HTTP request, is presented below.

<request_type_ID>1</request_type_ID> <session_id>1</session_id>

<url>http://127.0.0.1/servlet/RequestBroker</url>

<param>

<name>TARGET</name><value type= "text" maxlength= "20">Support</value>

<name>APPLICATION</name><value type= "text" maxlength= "20">Profile</value>

<name>ACTlON</name><value type= "text" maxlength= "20">Create Profile</value> <name>PASSWORD</name><value type= "text" maxlength= "207> <!~comment: Birthdate format is DDMMYYYY -> <name>BIRTHDATE</name><value type= "text" maxlength= "8'7>  <name>GENDER</name><value type= "text" maxlength= "1"/> <name> CONTACTADDR</name><value type= "text" maxlength= "1007> <name>PROFESSION</name><value type= "text" maxlength= "507> <name>PHONE1</name><value type= "text" maxlength= "28"/> <name> PHONE2 </name><value type= "text" maxlength= "28"/> <name> PHONE3 </name><value type= "text" maxlength= "287> <name> EMAIL1 </name><value type= "text" maxlength= "80'7> <name> EMAIL2 </name><value type= "text" maxlength= "80"/> <name> LANGID </name><value type= "text" maxlength= "27>

<name>MSISDN</name><value type= "text" maxlength= "257> <name>ACCESSLEVEL</name><value type= "numeric"/> <!-comment:Possible values for InstMsg are 'y' and 'n'--> <name>INSTMSG</name><value type= "text" maxlength= "1'7>

<!-comment: Birthdate format is DDMMYYYY->

<name> TRIALBEGINDATE</name><value type= "text" maxlength= "87>

<!~-comment: Endate format is DDMMYYYY-> <name>TRIALENDDATE</name><value type= 'text' maxlength= "87>

</param>

</request> The example XML description-based request above is written for automatic test case generation, for testing and analyzing operation of the server Most of the values in the XML-based request have been left empty If we wanted to specify each parameter value exactly (for example, in the recording of the user's actions) the parameters would be defined as follows <name>BIRTHDATE</name><value>03031972</value> rather than this

<name>BIRTHDATE</name><value type= "text' maxlength= "87>

The tags used are explained as follows <request> request definition

<request_type_ID> automatically generated unique identifier for the request

<sessιon_ιd> session identifier of the request (request id is usually a sequence of characters transferred in the HTTP header data, often called a "Cookie" in HTTP terminology) <url> URL (Universal Resource Locator), e g HTTP- address of the request

<method> HTTP method (usually GET or POST)

<param> specifies parameters of the request, for each parameter there are <name> and <value> tags corresponding to the name and value of the name and value of the parameter, respectively Referring to FIG. 6, the HTTP request generator 402 of the present invention may be implemented using hardware, software or a combination thereof and may be implemented in a computer system or other processing system. In an illustrative embodiment, the invention is directed toward one or more computer systems capable of carrying out the functionality described herein. An example computer system 600 is shown in FIG. 6. The computer system 600 includes one or more processors, such as processor 604. The processor 604 is connected to a communication bus 606. Various software embodiments are described in terms of this example computer system. After reading this description, it will become apparent to a person skilled in the relevant art how to implement the invention using other computer systems and/or computer architectures.

Computer system 600 also includes a main memory 608, preferably random access memory (RAM), and can also include a secondary memory 610. The secondary memory 610 can include, for example, a hard disk drive 612 and/or a removable storage drive 614, representing a floppy disk drive, a magnetic tape drive, an optical disk drive, etc. The removable storage drive 614 reads from and/or writes to a removable storage unit 618 in a well-known manner. Removable storage unit 618 represents a floppy disk, magnetic tape, optical disk, etc. which is read by and written to by removable storage drive 614. As will be appreciated, the removable storage unit 618 includes a computer usable storage medium having stored therein computer software and/or data.

In alternative embodiments, secondary memory 610 may include other similar means for allowing computer programs or other instructions to be loaded into computer system 600. Such means can include, for example, a removable storage unit 622 and an interface 620. Examples of such include a program cartridge and cartridge interface (such as that found in video game devices), a removable memory chip (such as an EPROM, or PROM) and associated socket, and other removable storage units and interfaces which allow software and data to be transferred from the removable storage units to computer system 600.

Computer system 600 can also include a communications interface 624. Communications interface 624 allows software and data to be transferred between computer system 600 and external devices. Examples of communications interface 624 can include a modem, a network interface (such as an Ethernet card), a communications port, a PCMCIA slot and card, etc. Software and data transferred via communications interface 624 are in the form of signals which can be electronic, electromagnetic, optical or other signals capable of being received by communications interface 624. These signals are provided to communications interface 624 via a communications path 626. This communications path 626 carries signals and can be implemented using wire or cable, fiber optics, a telephone line, a cellular phone link, an RF link and other communications channels.

In this document, the terms "computer program medium" and "computer usable medium" are used to generally refer to media such as removable storage device 618, a hard disk installed in hard disk drive 612, and communications path 626. These computer program products are means for providing software to computer system 600.

Computer programs (also called computer control logic) are stored in main memory 608 and/or secondary memory 610. Computer programs can also be received via communications interface 624. Such computer programs, when executed, enable the computer system 600 to perform the features of the present invention as discussed herein In particular, the computer programs, when executed, enable the processor 604 to perform the features of the present invention Accordingly, such computer programs represent controllers of the computer system 600

In an embodiment where the invention is implemented using software, the software may be stored in a computer program product and loaded into computer system 600 using removable storage drive 614, hard drive 612 or communications interface 624 The control logic (software), when executed by the processor 604, causes the processor 604 to perform the functions of the invention as described herein

In another embodiment, the invention is implemented primarily in hardware using, for example, hardware components such as application specific integrated circuits (ASICs) Implementation of the hardware state machine so as to perform the functions described herein will be apparent to persons skilled in the relevant art(s)

In yet another embodiment, the invention is implemented using a combination of both hardware and software

While various embodiments of the present invention have been described above, it should be understood that they have been presented by way of example, and not limitation It will be apparent to persons skilled in the relevant arts that various changes in form and detail can be made without departing from the spirit and scope of the invention

Claims

1. An apparatus, comprising: an HTTP request generator making an HTTP request based on an XML description; and a server receiving the HTTP request and responding to the HTTP request generator.

2. The apparatus of claim 1 , wherein: the server sending a file to the HTTP request generator in response to the

HTTP request.

3. The apparatus of claim 1 , wherein: the HTTP request generator parses the XML description to make the HTTP request.

4. The apparatus of claim 1 , wherein: the HTTP request generator augments a browser.

5. The apparatus of claim 4, further comprising: a client computer on which the browser is running; and a memory associated with the client computer.

6. The apparatus of claim 5, wherein: the XML description is stored in the memory.

7. The apparatus of claim 1 , wherein: the HTTP request is a test case for the server.

8. A method, comprising: making an XML description; and making an HTTP request based on the XML description.

9. The method of claim 8, further comprising: processing the XML description to make an XML file, parsing the XML file to make a parse tree; and compiling the parse tree to make the HTTP request.

10. The method of claim 8, further comprising: sending the HTTP request to a server.

11. The method of claim 10, further comprising: receiving the HTTP request.

12. The method of claim 11 , further comprising: serving a file in response to the HTTP request.

13. The method of claim 10, further comprising: using the HTTP request to test the server.

14. The method of claim 10, further comprising: recording the HTTP request.

15. A computer readable medium having stored thereon instructions which, when executed by a processor, cause the processor to perform a method, said method comprising: making an XML description; and making an HTTP request based on the XML description.

16. The computer readable medium of claim 15, said method further comprising: processing the XML description to make an XML file, parsing the XML file to make a parse tree; and compiling the parse tree to make the HTTP request.

17. The computer readable medium of claim 15, said method further comprising: sending the HTTP request to a server.

18. The computer readable medium of claim 17, said method further comprising: receiving the HTTP request.

19. The computer readable medium of claim 18, said method further comprising: serving a file in response to the HTTP request.

20. The computer readable medium of claim 17, said method further comprising: using the HTTP request to test the server.

21. The computer readable medium of claim 17, said method further comprising: recording the HTTP request.

AMENDED CLAIMS

[received by the International Bureau on 04 February 2002 (04.02.02); original claims 1 , 2, 4, 5, 8-21 amended; new claims 22-3 1 added; remaining claims unchanged (5 pages)]

1 . An apparatus, comprising: an HTTP request generator providing an HTTP request based on an XML description; a server receiving the HTTP request and responding to the HTTP request generator; and analyzing means which analyzes a response of the server to the HTTP request.

2. The apparatus of claim 1 , wherein: the server sends a file to the HTTP request generator in response to the HTTP request.

4. The apparatus of claim 1 , wherein: the HTTP request generator provides a browser.

5. The apparatus of claim 4, further comprising: a client computer on which the browser runs; and a memory associated with the client computer.

7. The apparatus of claim 1 , wherein: the HTTP request is a test case for the server. The apparatus of claim 7, wherein: the HTTP request and the response to the test case is in XML format.

9. The apparatus of claim 2, comprising: a request recorder which records the HTTP request to permit investigation of the recorded HTTP request.

10. The apparatus of claim 1 comprising: a request recorder which records the HTTP request and automatically reruns the recorded HTTP request.

1 1 . The apparatus of claim 1 comprising: a request recorder which records the HTTP request to provide a safety record.

12. The apparatus of claim 1 comprising: a request recorder which records the HTTP request which include a credit card number of the user.

13. The apparatus of claim 1 comprising: a request recorder which records the HTTP request; and means, responsive to the request recorder, which undoes the recorded HTTP request.

14. A method, comprising: making an XML description; making an HTTP request based on the XML description; sending the HTTP request to a server; providing fro the server an HTTP response; and storinq the HTTP request for analysis.

15. The method in accordance with claim 14 wherein: the recorded request is in XML format.

16. The method in accordance with claim 14 wherein: the recorded HTTP request includes a storage for any HTTP request which includes an error; an operator of the apparatus accesses any recorded HTTP request which contains an error; and the operator attempts to rerun any recorded HTTP request which contains an error with an automatic test tool.

17. The method in accordance with claim 14 wherein: the recorded HTTP request provides safety information.

18. The method in accordance with claim 14 wherein: the recorded HTTP request includes a credit card number.

19. The method of claim 14 wherein: the storing of the HTTP request is used to undue the HTTP request into the XML format.

20. The method of claim 14, further comprising: processing the XML description to make an XML file; parsing the XML file to make a parse tree; and compiling the parse tree to make the HTTP request.

21 . The method of claim 14, comprising: sending the HTTP request to a server.

22. The method of claim 21 , comprising: receiving the HTTP request.

23. The method of claim 22, further comprising: serving a file in response to the HTTP request.

24. The method of claim 21 , further comprising: using the HTTP request to test the server.

25. The method of claim 21 , further comprising: recording the HTTP request.

26. A computer readable medium having stored thereon instructions which, when executed by a processor, cause the processor to perform a method, said method comprising: processing an XML description to make an XML file; and making an HTTP request based on the XML file by compiling the parse tree to make the HTTP request.

27. The computer readable medium of claim 26, said method further comprising: sending the HTTP request to a server.

28. The computer readable medium of claim 27, said method further comprising: receiving the HTTP request.

29. The computer readable medium of claim 28, said method further comprising: serving a file in response to the HTTP request.

30. The computer readable medium of claim 27, said method further comprising: using the HTTP request to test the server.

31. The computer readable medium of claim 27, said method further comprising: recording the HTTP request.