KR20040050463A - Appratus and Method for Enterprise JavaBean Component Testing - Google Patents

Abstract

PURPOSE: A device and a method for testing an EJB(Enterprise Java Bean) component are provided to automatically verify that a realized software component satisfies the required particulars, and reduce the repeated testing processes through reuse in case that a developer develops a server side component. CONSTITUTION: A class analysis module(210) analyzes an inputted class(100) by using a reflection API(Application Programming Interface) supported on the Java and extracts the information for the class. An information storage(230) stores the information for the extracted component class. An XML(eXtensible Markup Language) loader module(220) generates a test case of the testing class as an XML file form by receiving the class information stored in the information storage. A test client generating module(240) generates a test client(260) by using an XML document generated from the XML loader module. A test data generating module(250) generates the test data by using the XML document. A testing server module(270) performs a test by dynamically instancing the test client and the test data to the XML document and the test client object through the Java reflection.

Description

Apparatus and Method for Enterprise JavaBean Component Testing}

The present invention relates to a Gray Box software testing apparatus and method for an Enterprise Java Beans component installed on a server side through the Internet, and more particularly, to a server side on which a target component is to be actually operated. It is a test client and a testing server device for easily testing test conditions and automatic generation of test cases and test data in order to perform testing in a state and to test a target component.

Software testing verifies that a program has been implemented in accordance with a given requirement to detect errors or defects in a program. The general structure for testing software is to first select the target language to be tested and then implement a parser for the selected language. After that, the analysis information is extracted from it, and the extracted analysis information is mainly used to generate test cases and test data necessary for testing.

However, there can be numerous paths within a simple program, and as the program grows in size, it grows exponentially. As a result, it is almost impossible to implement complete software, so software testing should be done with some testing limitations and efficiency.

Software testing is generally divided into unit testing, integration testing, system testing, and acceptance testing, depending on the level of abstraction.

Unit testing is called module testing, and independently tests only the target module regardless of other modules. This requires a test harness.

Integration testing examines the binding relationships and interactions between modules. System testing is to test the system software with the modules required for the whole system fully equipped, and final acceptance testing is to confirm customer satisfaction from the user's point of view of the completed software system.

In terms of software testing techniques, it can be largely divided into black-box and white-box.

The black box testing is based on the input and output data using the detailed specification of the software or the requirements analysis specification without considering the internal operation of the software, and is called behavioral testing.

In addition, black box testing includes functional testing for testing software functions and boundary-value testing using boundary values.

The white box testing, in other terms, is called structural testing and tests whether the software performs satisfactorily. Whitebox testing includes control-flow driven testing, data-flow driven testing, mutation testing, and domain testing.

Gray-box testing takes the form of black box testing and white box testing.

Graybox testing is a software testing technique applied to integration testing at the software testing abstraction level. The technique involves testing the interrelationships between components based on their component interfaces. In other words, the component itself is a black box, but each I / O interface is already publicly known, so testing is done using this interface.

A service component for providing services to a plurality of clients via the web is installed on the server side. The component can then access remote databases and interact with components on other servers. For example, Sun has published a standard specification for a web application server called J2EE for developing component-based software with Enterprise JavaBeans.

The developed components are installed and operated on the server side, and these components can be executed independently, but are often operated by exchanging information with a database or other components. In this case, for clear interface testing of developed server components, testing should be done on the server side.

Techniques related to the present invention include techniques related to object-oriented software testing. The technology related to software testing is the application of the white box testing technique. The program area used for the previous testing includes an automatic testing technique (US Pat. No. 5758061) to avoid testing again, a test drive and a test case for object-oriented software testing. There is a technique (US Patent, 6353897) for testing using a software test frame. In addition, the method of dynamically generating Java classes or Java Beans and binding metadata separated into files (US Patent, 6427228) is similar to the present technology.

These prior arts do not include a description of the software being done on the server side, with the program being tested and the testing program focused only on the same machine. In the case of components related to other components or resources on the server side, i.e., resources such as a database, it is not only difficult to test whether the component works properly, but also requires a lot of manual work and effort.

Therefore, there is a need for an automated testing method that makes it easier to test components that are running on the server side, and when retesting the same components, there is a need for a method that enables faster testing by reusing existing test cases.

The present invention is to solve the above problems, in detail, when a developer develops a server-side component, and automatically verify whether the implemented software component satisfies the requirements, and re-use the repeated testing process again An object of the present invention is to provide an enterprise Java bean component testing apparatus and a method thereof.

The object can be achieved by providing an enterprise Java bean component testing apparatus of the present invention by providing a gray box testing apparatus for integrated testing in software testing, the present invention provides a device for testing a class file that is a compiled form of a component A class analysis module for analyzing an input class using a reflection API supported by Java and extracting information about the class; An information store for storing information about the extracted component class; An XML loader module for generating a test case of a class to be tested by receiving class information stored in the information repository in the form of an XML file; A test client generation module generating a test client using the XML document generated by the XML loader module; A test data generation module for generating test data using the XML document generated by the XML loader module; And a testing server module configured to dynamically instantiate an XML document and the test client object and test the test client and the test data using Java reflection.

1 is a system for testing the enterprise Java bean component of the present invention.

System Configuration,

2 is a detailed configuration diagram of the testing server of the present invention,

3 is an algorithm flowchart of an XML loader module of the present invention;

4 is a diagram showing an example of an XML file generated by the XML loader module of the present invention;

5 is an XML example file generated by the test data generation module of the present invention;

6 is a test client generated by the test client generation module of the present invention.

Client examples,

7 is a detailed flowchart of the testing server module of the present invention;

8 shows the input test data and the output result of the testing server module of the present invention.

Example file expressed as XML document,

Explanation of symbols on the main parts of the drawings

200; testing server 210; class analysis module

220; XML loader module 240; test client generation module

250; test data generation module 270; testing server module

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 illustrates a system diagram for testing an enterprise Java bean component of the present invention. 1 illustrates an example of an environment of an entire system in which a testing server 200 according to the present invention is operated, and a user compiles to implement and execute a program.

For example, compiling the Java language, an object-oriented language, creates a class file. In the case of an enterprise Java bean, it consists of a bean class, home interface, remote interface, and other classes. These classes 100 are installed in the server machine 120 in binary form except source code, and the testing server 200 verifies whether the enterprise bean installed in the server machine 120 works well with other modules through the network. .

FIG. 2 is a detailed diagram illustrating the testing server 200 of the present invention in detail and shows a flow of automatically testing information by extracting information of a class to be tested.

Referring to the drawings, the testing server 200 of the present invention is a class analysis module 210, XML loader module 220, information store 230, test client generation module 240, test data generation module 250 and The testing server module 270 is included.

The class analysis module 210 of the present invention uses a reflection API supported by Java when a user inputs a class component, which is a compiled form of a server component, that is, a component, to a class analysis module 210. It analyzes the input class, extracts information about the class and stores it in the information store 230 for use in other modules.

The XML loader module 220 automatically generates a test case of a class to be tested by receiving class information stored in the information store 230 in the form of an XML file, and then generates a finally generated XML document by the test client 260. The test client generating module 240 and the test data generating module 250 for automatically generating the test data are generated to generate the test data.

The XML document generated by the XML loader module 220 can effectively express data having a hierarchical structure and can be easily converted into other types of documents. It has the advantage that the end user can easily understand and modify the document.

In the present invention, test cases are defined as methods or interfaces set to public of each class. The test data refers to input and output data required for each test class.

The test client generation module 240 generates the test client 260 using the XML document received from the XML loader module 220. The test client 260 includes all test cases required for testing and is thread based.

Meanwhile, the test data generation module 250 automatically inputs test data using an XML document input from the XML loader module 220. In this case, the test data is formed in a random form and has a boundary value. value) A random data pattern may be defined and used in advance for testing.

The testing server module 270 receives the test data applied by the test data generation module 250 and the test client 260 generated from the test client generation module 240 to test the Java class.

The testing server module 270 dynamically instantiates a test client 260 object using a Java reflection function, where the instantiated test client 260 object uses test data in a testing server to test data. And execute the thread of the test client 260.

In addition, the testing server module 270 can take over the test result value from the test client after the testing is completed, and store the data as an XML document again in the information storage 230 so that the test server module 270 can be reused when testing a component having the same interface. To make it work.

Figure 3 is a detailed view showing a testing server module of the present invention in detail. Referring to the drawings, the testing server module 270 of the present invention tests the XML document defining the test client generated by the test client generation module 240 and the test data generated by the test data generation module 250.

That is, the testing server module 270 extracts data to be delivered to the data object through XML unmarshalling 271 from the XML document generated by the test data generation module 250. The information extracted by the XML unmarshalling 271 instantiates the data object extracted using the Java reflection function through the data object calling unit 271, and the instantiated data object is instantiated through the data binding unit 274. Set the value in the object.

The object value set through the data binding unit 274 transfers the data to the test client 260 as a parameter of the constructor when the test client is instantiated through the test client caller 275, and the test data delivered. Changes in will result in different test clients.

After executing different test clients using threads, the test results are returned from each test client, the information is aggregated, and the test data results are sent to the XML marshalling 272. After converting the data into the information storage 230, the components having the same interface can be reused when testing.

4 is a flowchart illustrating an algorithm of the XML loader module of the present invention. Referring to the drawings, the XML loader module 220 of the present invention is analyzed by the class analysis module 210 as the information stored in the information store 230 as an input, the information input to the XML loader module 220 is tested Through the case search (S410), the test cases and candidate interfaces that can be accessed are found. For example, in an enterprise Java bean, you can't access the bean class directly, so you can access it using either the home interface or the remote interface, and only select methods that have public declarations on those interfaces.

If any test case is selected, after analyzing the information about the input parameter and output type for the test case (S420) and checking whether the input or output of the test case includes a user-defined class other than the general class ( S430).

If the test case does not include the user-defined class in step 430, the identified information is added to the XML file (S460). On the contrary, if the test case includes the user-defined class, the class is serializable. Check the idle (S440).

As a result of the determination in step 440, if serialization is possible in the state where the user-defined class is included in the test case, information on the user-defined class is extracted (S450). Here, a custom class can have an inner class and iteratively repeats until there is no inner class, and, conversely, ends testing if the custom class is not serializable.

Finally, in step 460, after adding the information identified by the user-defined class to the XML file and no further test cases exist, proceed to the next test data generation module or test client generation module process, and if additional test cases exist Returning to step 410 to repeat the previous process (S470).

Hereinafter, the present invention will be described in detail with reference to FIGS. 5 to 8. FIG. 5 illustrates an example of an XML file generated by the XML file writing step S460 of FIG. 4.

Referring to the drawings, reference numeral 500 denotes a test case set, 510 denotes a test case, 520 denotes a method tag, 530 denotes a parameter tag, and 540 denotes a return tag. The test case set 500 according to the present invention displays a testable test case list, and the test case set 500 includes a plurality of test cases 510.

The test case 510 is a class name to which the test case to be tested belongs. Here, the test case 510 may be a home interface or a remote interface in the case of an enterprise Java bean as shown in FIG. 4.

The test case 510 expresses information about a method for testing. Method tag 520 becomes a test method, and parameter tag 530 shows the name and type of the parameter.

In case of user defined class, it is expressed by package name and class name. The next return tag 540 represents the return information of the method. If the type is void, the type is represented as void. If the return object is a user-defined object, it can also be represented recursively.

6 shows an example of an XML file generated by the test data generation module 250 of the present invention. This XML file is a file that defines data so that various input tests can be given to the test client with different inputs.

Here, the class tag 600 is a class name of a test case as shown in FIG. 5, and the parameter tag 610 sets data to be input. The test data generation module 250 analyzes the content of FIG. 4 generated by the XML load module 220 and expands the test data portion to automatically set the input data randomly.

7 illustrates an example program for the test client 260 of the present invention.

Referring to the drawings, the present invention inherits a threadable interface to set the test client name 700 in the test client source and operate in the form of threads. When the object is dynamically generated by the testing server module 270, the test client takes over the test data object in which data binding is performed using the constructor parameter 710. The required methods in the client class are the run () and getResult () methods. The run () method inherits from the Runnable interface and must be implemented.

In the present invention, the detailed implementation code 720 of the method is automatically generated by the test client generation module. The run () method is executed using the method name 740 of each test case. In addition, all results generated by calling run () method are stored through the hash table result and finally, when requested by the testing server module 270, the test result value is returned using the getResult () method 730.

8 is an example file representing an input test data and an output result of the testing server module 270 of FIG. 3 in an XML document.

The overall structure is similar to that of Fig. 6 and it can be seen that the data of the output portion is added. The test results 800 and 810 show processed results from different test data, and the error test results 820 are shown in null form.

As described above, the present invention automatically generates various test cases and data when testing a server component implemented in an object-oriented language, and generates it as an XML document. The generated XML document can be easily changed by the user and is used as a means of dynamically passing data to the test client, so that server-side component testing can be tested more flexibly and conveniently. The advantage of reusing XML documents when testing a component with.

What has been described above is just one embodiment of the testing apparatus and method for the enterprise Java bean component of the present invention, and the present invention is not limited to the above-described embodiment, and the present invention is claimed in the following claims. Without departing from the gist of the present invention, those skilled in the art to which the present invention pertains to the spirit of the present invention to the extent that various changes can be made.

Claims (8)

In a device for testing a class file that is a compiled form of a component, A class analysis module for analyzing an input class and extracting information about the class using a reflection API supported by Java; An information store for storing information about the extracted component class; An XML loader module for generating a test case of a class to be tested by receiving class information stored in the information repository in the form of an XML file; A test client generation module generating a test client using the XML document generated by the XML loader module; A test data generation module for generating test data using the XML document generated by the XML loader module; And A testing server module configured to dynamically instantiate an XML document and the test client object and test the test client and the test data using Java reflection; Enterprise Java bean component testing apparatus comprising a. The method of claim 1, wherein the testing server module, XML unmarshalling for extracting data for transfer to a data object for the XML document generated by the test data generation module; A data object caller configured to instantiate a data object using a Java reflection function on the data extracted through the XML unmarshalling; A data binding unit configured to generate an object by setting a value in the object from the instantiated data object; A test client caller configured to change test data as a parameter of a constructor for the object created by the data binding unit, and then transfer the test data to the test client and return a test result; And XML marshalling to convert the test result returned through the test client caller to an XML document and to store in the information store; Enterprise Java bean component testing device, characterized in that consisting of. The method of claim 1, wherein the test data generated by the test data generation module is random and is used in advance to define a random data pattern to perform a boundary-value test. Enterprise Java bean component testing device. The apparatus of claim 1, wherein the test client includes a test case for testing and is thread-based. In the method for testing a class file that is a compiled form of a component, Analyzing a class using a reflection API supported by Java, and extracting and storing information about the class; Generating a test case of a class to be tested against the stored class information in the form of an XML file; Generating test data with a test client using the XML file; And And instantiating the XML file and the test client object dynamically using Java reflection. The method of claim 5, wherein the generating of the class test case into an XML document comprises: Searching for a test case with respect to the extracted component class information, and analyzing information about an input parameter and an output type of the test case; Determining whether the user-defined class is included in the information about the input or output type of the test case, and if the user-defined class is included, adding the class to the XML file; And And repeatedly searching until the test case does not exist for the class defined by the user in the class information. The method of claim 6, wherein the information about the input or output type of the test case does not include a class defined by the user, and determines whether serialization is possible. An enterprise Java bean component testing method comprising the steps of: The method of claim 5, wherein the test client receives data as a constructor parameter from a testing server module and returns data through a getResult () method.