Shulou(Shulou.com)06/03 Report--

Introduce:

In fact, those who are familiar with selenium must be familiar with the wire protocol, because we know that when we use WebDriver API to do something in the code, it will eventually turn into a wire protocol-based command (Command) to be sent to the browser, and the content of the request will be encapsulated in the json object, calling the browser through WebService, so that all calls to WebDriver API will eventually be converted to WebService calls to the browser.

Here we will study the wire protocol through the simplest input text content (WebElement.sendKeys (String)). And all the details above.

The reference specifications for the Wire protocol are as follows:

Http://code.google.com/p/selenium/wiki/JsonWireProtocol

At a glance, the wire protocol is powerful enough to operate almost anything a natural person can do to a browser, such as opening, closing, clicking, closing, locating, uploading files, minimizing, and so on.

It is a set of web service based on RESTful style.

Debugging actual combat:

For example, there is an input box on the page called id called policy-name, and then the value we want to enter is in the dataProvider object, then the automated test code is:

The sendKeys () method is as follows:

When the sendKeys method is called, it converts the value we want to enter into an array of characters, which is easy to understand because any string is a collection of keyboard inputs. So the value of our policyName is converted to:

Then, it calls the execute () method on line 87 and uses the Command design pattern, changing the name of our calling sendKeys (String) method to a command DriverCommand.SEND_KEYS_TO_ELEMENT (that is, the string "sendKeysToElement"), and then packaging the content keysToSend variable we want to send through ImmutableMap, in order to make our input immutable.

Because in our example, we are using Firefox on the Linux operating system, it calls the execute () method on FirefoxWebElement, and our input is wrapped by ImmutableMap with WebElement's id.

It then calls the parent class's execute () method to complete the operation:

This is the most important method, and we analyze it carefully:

From a macro point of view, first of all, in line 436, the sessionId corresponding to the session created from the current WebDriver to the browser it launches, as well as the command string (that is, the DriverCommand.SEND_KEYS_TO_ELEMENT string constant passed above), as well as the wrapper of the sent string content, are all encapsulated in a Command object, which is encapsulated as follows:

It is worth mentioning that this sessionId is the only session id assigned by WebDriver each time the browser is launched, thus ensuring that there is no problem with the multithreaded parallel runtime, and that the request is always sent to the webservice contained in the correct browser. (we will talk about this in essence Analysis 1.)

Then, on line 446, it uses the execute () method of CommandExecutor to execute Command to send the command to the web service service included in the browser specified by sessionId, and eventually it uses HttpCommandExecutor to accomplish this task

(the details of executing the command are the main purpose of our exploration, which reflects the web service call based on the wire protocol, which we discussed in essence Analysis 2.)

Finally, do some post-processing on lines 455-456 for the return of the execution result, so you can see the animation of the automated test on the page.

How does essence analyze how 1:sessionId is produced?

Because we are using the test done by Firefox browsers (as do other browsers), when WebDriver starts the browser, it calls the webDriver = new FirefoxDriver (firefoxBinary,firefoxProfile) method

Because FirefoxDriver inherits from RemoteWebDriver, the constructor of RemoteWebDriver is called when the FirefoxDriver constructor is called, and the startSession () method is called on the last line as follows:

StartSession will use the Command pattern at the beginning, calling the execute () method to create a new session:

This execute method, which is eventually executed by HttpCommandExecutor, sends a Http request, as described earlier, and all the request details are in the Command object. As you can see from the following debugging information, Command is the following information:

Its command name is newSession, and sessionId is empty because it hasn't been created yet.

Then the info object contains the request url to be sent, and you can see that the request url it is sent to is / session

Finally, from the httpMethod object, we can see that httpMethod uses HttpPost.

So contact the above information to know that in RemoteWebDriver, it actually sends a request object to / session with the HttpPost method, and the request object contains the command "newSession" and some desiredCapabilities information.

Let's compare the wire protocol:

As described in the protocol, this request is used to create a new session. We check the parameters, the request type, and the request payload is exactly the same.

So the request will be sent eventually, and the newly created sessionId will be included in the sent response.

The sessionId can then be used as the identity of the target browser to which each request is sent, thus ensuring that each request is the correct browser, and of course, the sessionId must be included in each request.

Analyze the details of 2:HttpCommandExecutor 's execution of commands.

Let's take a look at the HttpCommandExecutor.execute () method:

First of all, it will convert the name of command (command name, that is, our DriverCommand.SEND_KEYS_TO_ELEMENT) to a command in the form of url on line 279. Recall that we used REST, so the command is also expressed in the form of a path expression. After conversion, the CommandInfo is as follows:

So the sendKeysToElement command is converted to the url form of POST / session/:sessionId/element/:id/value.

Let's compare the description of the Wire protocol:

So, we got it right here, and it's true that the ultimate goal of our sendKeysToELement is to send a sequence of keystrokes to the specified element.

It then separates the Http action from the previous CommandInfo object on line 281:

And inside this getMethod method, all the url indicated by the name parameter (: sessionId) and (: id) in our url will be replaced with the real value, and the server request url specified by the remoteServer instance variable will be spliced in front of it.

Because in terms of debugging information, the verb (verb) in info is called "POST", it will eventually be converted to httpMethod to HttpPost. And this uri is specified by the variable and converted to:

Here you can see that (: sessionId), (: id) have been replaced, where sessionId comes from the browser's sessionId. For more information, please see essence Analysis 1.

Then set HttpPost to the Http Accept header on line 283.

Then it will be processed differently according to different HttpMethod, because our request is a httpPost request, so it will use BeanToJsonConverter () on line 286 to convert the content we encapsulated in the Command object into payload in json format, and then set the encoding format of payload as well as the Content-Type content.

After the conversion, the json becomes:

Finally, in line 297 to send the browser by calling fallbackExecute, you can see that this is indeed a Web Service call to RESTful.

After processing, the result is encapsulated in the HttpResponse object, and we need to post-process it. From the debugging information, the Response is a standard HttpResonse.

We found a very interesting thing, here found that the server is httpd.js, which shows that, in fact, the real consumption of our Http request is the browser built-in a httpd.js script, which is also in line with our theoretical model (the browser contains a js to specifically deal with requests based on the wire protocol), we can guess that this js is an animation that simulates input values to the input box.

I found this js file on the official website of selenium, and its content is: http://code.google.com/p/selenium/source/browse/firefox/src/extension/components/httpd.js?spec=svn004f447f8b359859da694f79569d7e5b03470dd7&r=004f447f8b359859da694f79569d7e5b03470dd7

When we get the Response object, we have to do post-processing, we are not interested in post-processing, so we will not analyze it.

Summary:

We can get a lot of useful information from here.

(1) from an architectural point of view, when we use WebDriver API calls to write code for automated testing, eventually these method calls will be converted into web service calls based on wire protocol within the selenium framework. The design pattern adopted is the Command pattern, the server side of this web service is included in any browser, and the code used for the service is actually httpd.js.

(2) wire protocol can simulate almost anything that a natural person can do to the browser, such as opening, closing, clicking, closing, locating, uploading files, minimizing and so on. It is a set of web service based on RESTful style.

(3) every time web service is called, there must be a sessionId as part of the request URL. This sessionId is used to uniquely identify the browser to which the request is sent, and it is the only URL, so as to ensure the correctness of working in a multithreaded environment. It is generated by initializing the browser's WebDriver, sending a web service with Command as newSession to the browser, the request path is / session, and the payload contains the desireCapability information of the target browser, so that the call to this web service will return a sessionId and be included in all subsequent operations.

(4) in the specific execution of an API call, such as sendKeys, it will be converted to a web service call, and the called url will contain sessionId and other related information in the form of name parameters, which will be replaced by actual parameters at the beginning of the call process. Then all the parameter information encapsulated in the Command will be converted to a json object as the payload of the web service, and the request type will be specified according to your actual request action, and the final request call process is a web service call process. Its server is implemented by various browsers and is included in a piece of code called httpd.js.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.