What are the good tools for http interface testing

Latest Modification: Added HTTPS URL requests, currently supports HTTP and HTTPS.

Interface testing is a type of testing that tests the interface between system components. Interface testing is mainly used to detect the interaction points between external systems and between various subsystems inside. The focus of the test is to examine the process of exchanging, transmitting and controlling the management of data, as well as the logical dependencies between systems.

Interface testing is generally used for the interactive development of multiple systems, or the development of application systems with multiple subsystems. Interface testing is applicable to the underlying framework system and the central service system that provide services for other systems, mainly to test the interfaces provided by these systems to the outside to verify their correctness and stability.

The simplest application is to use Web HTTP to provide data interfaces for the APP, these interfaces have a certain degree of dynamics, using certain parameters to be passed, the interface obtains different data through parameters and returns to the user, there are two ways to pass in parameters, get and post, and the browser can directly simulate the get request, but the POST request can only be written for testing, which leads to very troublesome interface testing.

This tool provides HTTP GET and POST tests for any interface, and provides the test return value, interface return time, and has obtained the abnormal state of the interface request, and then fed back to the user.

There are currently two mainstream approaches.

The first is written based on the first framework.

The second option is to use the interface test tool directly.

As a newcomer who has been engaged in front-end development for nearly a year, I used to use word documents to communicate with my colleagues in the background. When you take the test, you can only write a test by yourself** test little by little.

Hello, for interface testing, first of all, the tester must understand**, you only need to know what the function of the interface is (it is better to have documentation, but most of them are not); Secondly, read the development of ** yourself; Then, write the test case according to the interface function and **.

Use case design: 1: Write a program to call the interface to see if it can achieve the function defined by the interface.

2: According to the parameters of the interface, construct different use cases to test whether the interface can achieve the expected effect under the condition that the parameters are legal or illegal.

3: According to the logic in the interface, design use cases with different conditions, and test the logic of the interface implementation.

4: Perform fault tolerance and robustness testing.

5: Static detection to see if there is a memory leak, or a branch that can never be reached, whether the specification and logic are reasonable.

6: For some interfaces, multi-threaded testing is required.

What is Interface Testing

Interface testing is a way to test the interface between system components, and interface testing is mainly used to detect the interaction points between external systems and between various internal subsystems. The focus of the test is to check the addition, deletion, modification and query operations of data, as well as the logical relationship between systems.

Several types of HTTP (several types of interfaces).

The following types of interfaces are: post, get, put, and delete.

The difference between post and get: the POST parameter exists in the form of a form in the POST parameter, and the GET parameter exists in the url.

get: requests to obtain the resources marked with request-url.

post: Submit or append new data to the resource identified by request-url.

put: It is very similar to post, it is also imagining the server submitting data, put specifies the location of the resource on the server, and the post does not.

delete: Deletes a resource on the server.

How to do interface testing

The interface test is only a functional test without an interface, and the design idea is basically the same as the functional test.

1. Test the input parameters.

1) According to the requirements of the parameters, judge whether the requirements are met, and the parameters should meet his requirements, for example, if you let you enter a number, then judge the input number --- integers, decimals, negative numbers, complex numbers and other numbers for normal testing, or super-large values and ultra-small values, and the abnormal test is to judge whether the response is normal when the number is not entered, it is kept empty, or the input is a string, not a number.

2) Whether the parameter is required, if it is required, fill in all the required items, and conduct an interface testWhen the required items are not filled, perform an interface test to see if there is an error.

3) If the parameter is optional, then test, if there are multiple optional items, test them one by one, fill in all the required items, and one optional item required, whether the interface returns correctly, and then test, when the selected fill-in item remains empty, whether it can be returned normally, and when there are multiple optional items, whether it returns normal.

4) If the parameter name is filled in incorrectly, whether it is an error, if there is an invalid parameter, whether it is an error, etc.

5) Perform a logical test for each interface, that is, for example, to add a new data, check the corresponding url, and then display the new data, that is, every time you add a new data, delete or change the description, you have to check and query.

6) There are also some exceptions to be considered in the interface, such as the permission problem, party A has established multiple contents, and party B uses the interface to see if it can be deleted.

7) Interface testing also has to consider various logical and practical problems, which needs to be tested according to the usability of the project itself, which can be completely imagined as a functional test.

8) Also consider whether the interface is submitted repeatedly and whether it reports an error.

9) Abnormal scenarios, such as request timeout, rapid continuous clicking, request failure, etc.

10) Security issues, such as whether the login password needs to be encrypted.

Interface testing is a type of testing that tests the interface between system components. Interface testing is mainly used to detect the interaction points between external systems and between various subsystems inside. The main focus of the test is to check the process of data exchange, transmission and control management, as well as the mutual logical dependencies between systems.

1. You can use postman software to test the interface, here we take the more complex interface of uploading ** as an example for testing, first open the postman software and select the post mode, and enter the background interface call address.

2. Then fill in the headers, note that don't write anything in the headers section here, if there is a content-type header before, then the upload will fail.

3. Then fill in the body, select form-data, fill in the name parameter of the received file specified in the key background, select the format as file, and the value will automatically become the selection file.

4. Finally, click send, and you can find that the interface response is returned below, indicating that the upload is successful, so that the simple upload interface test is completed.

The test process of an interface test.

After understanding what interface testing is, how do you do it? The process of interface testing is similar to that of functional testing: interface test plan - interface test case - interface test execution - interface test report.

The dependencies of test case design are mainly requirements specifications and interface documents.

Because the interface test is not for ordinary users, but for another system component, it cannot be tested directly, and it needs to be tested with tools, such as server-side HTTP interface test, commonly used tools such as jmeter, postman, httpclient, etc. Test with tools, so the goal is to prepare the test data test script and execute it directly, when writing the test execution, there are the following principles:

1.Different interface parameters cover different business scenarios;

2.Construct appropriate data in the background to meet the test cases of the interface;

3.Based on the return value of the interface, assert whether it returns the desired result or not, and look at the database validation;

4.If the test case involves multiple steps, all the steps involved should be verified;

5.Remove the results from the testing process to ensure a clean environment before each use case is executed.

1. What is interface testing: interface refers to the interaction between system modules or between systems, generally we use more HTTP protocol interfaces, WebService protocol interfaces, and RPC (Remote Procedure Call Protocol) interfaces. No matter what kind of interface it is, the essence of it is to send a request, and then the server responds and returns a response, and then we analyze the response, which is the interface test.

2. There are two types of message interface testing:

a) WebService: Use the SOAP protocol to get what you want (not divided into POST and GET, just wrapped based on the SOAP protocol), and can handle more complex data types (XML). If you need to call a service of another application in the background, use the webserivice method;

b) HTTP: Based on the HTTP protocol, you can get what you want through POST and GET, and the data processing efficiency is high. When you want to call the content of a service, use the httpservice method.

3. Commonly used interface testing tools are:

a) Commercial tools: SOAPUI, LoadRunnerB) urllib in open source tools, urllib2 library.

For interface testing, first of all, the tester must understand, you only need to know what the function of the interface is, and secondly, read the development by yourself.

Then, according to the function of the interface and write test cases: according to the interface parameters, construct different use cases, test whether the interface can achieve the expected effect in the case of legal and illegal parameters, test the logic of the interface implementation according to the logic in the interface, carry out fault tolerance and robustness testing, static detection, to see if there is a memory leak, or a branch that can never go away, whether the specification and logic are reasonable, for some interfaces, multi-threaded testing is required.

Interface testing is generally used for interactive development between multiple systems, or for application system development with multiple subsystems. Interface testing is applicable to the underlying framework system and the central service system that provide services to other systems.

It mainly tests the interfaces provided by these systems to verify their correctness and stability. Interface testing is also applicable to the service layer interface of an upper-layer system, and the higher the layer, the more difficult it is to test. The application of interface testing in ** is a bottom-up development process.

For interface testing, the repeated operation of project test cases is first manifested in the independence of a single test case, that is to say, the operation of each test case does not depend on any other test cases except for the test object and the corresponding database environment, and after the test case is executed, there is no trace for the system, so as to ensure that each test case runs in a clean environment. In order to achieve the independence of test cases, it is necessary to have a detailed understanding of the design of the system under test, so that there is no missing data after the test case is executed, the environment is not changed, and the test case needs to be designed in detail. In addition, in order to ensure the repeated use of test cases, it is also necessary to update the test cases in a timely manner, in this regard, we are the people who do interface testing will maintain the interface test cases of the corresponding system, to ensure that every time the test cases are updated, all the test cases must be executed.

The design method of the interface test case is actually similar to the design method of the functional test case, because the interface needs to meet the requirements, and the interface test also relies on the requirements specification, but, because the interface test is tested through ** after all, so, in order to ensure the coverage rate, the unit test method may be used, and the specific test case design, I consider the following, please refer to it, if there is an error, discuss it together.

Input parameter test: test for the input parameters, which can also be said to be a test assuming the incorrectness of the interface parameters, to ensure that the interface has handled any type of input accordingly: the input parameters are valid, the input parameters are invalid, the input parameters are null, and the input parameters are extra-long;

Functional test: Whether the interface meets the provided functions is equivalent to a normal test, and if an interface function is complex, it is recommended to divide the interface use case into structures, so that the sub-use cases have better readability and maintainability.

Logic test: Strictly speaking, the logic test should be a unit test, and the unit test should maintain the correctness of the internal logic, but the boundary between the unit test and the interface test is not so clear, so we can also consider the branch cases and exceptions of the internal logic errors from the given design documents; Exception test: whether the interface implementation has handled the exception, although the interface input parameters are legal, but in the interface implementation, there will also be exceptions, because the internal exceptions are not necessarily caused by the input data, but may be caused by other logic, and the program needs to handle any exceptions.