सेलेनियम वेबड्राइवर का उपयोग करके HTTP रिस्पांस कोड कैसे प्राप्त करें

Question

मैंने सेलेनियम 2 / वेबड्राइवर के साथ परीक्षण लिखा है और अगर HTTP अनुरोध एक HTTP 403 निषिद्ध रिटर्न देता है तो परीक्षण करना चाहता है।

क्या सेलेनियम वेबड्राइवर के साथ HTTP प्रतिक्रिया स्थिति कोड प्राप्त करना संभव है?

Comments

— Selenium.py

यह कोई डुप्लिकेट नहीं है, क्योंकि दूसरा प्रश्न पायथन पर केंद्रित है, लेकिन यह एक जावा में है,

— राल्फ

धन्यवाद मुझे मिल गया। लेकिन अंत में यह सवाल समाप्त हो गया webdriver, और ये सीमाएं पायथन और जावा दोनों के लिए समान हैं;)

— मैक्सिकोरुकोव

@maxkoryukov: लेकिन भाषा पर निर्भर वर्कअराउंड हैं,

— राल्फ

Answer 1

एक शब्द में, नहीं। यह सेलेनियम वेबड्राइवर एपीआई का उपयोग करना संभव नहीं है। इस परियोजना के लिए जारी ट्रैकर में विज्ञापन की चर्चा की गई है, और इस सुविधा को एपीआई में नहीं जोड़ा जाएगा।

Answer 2

सेलेनियम और क्रोम या फ़ायरफ़ॉक्स का उपयोग करके http अनुरोध का प्रतिक्रिया कोड प्राप्त करना संभव है। आपको बस लॉगिंग मोड में या तो क्रोम या फ़ायरफ़ॉक्स शुरू करना है। मैं आपको नीचे कुछ उदाहरण दिखाऊंगा।

जावा + सेलेनियम + क्रोम यहाँ का एक उदाहरण है, लेकिन मुझे लगता है कि यह किसी भी भाषा (अजगर, सी #, ...) में किया जा सकता है।

आपको केवल "Network.enable" करने के लिए क्रोमेड्रिवर को बताने की आवश्यकता है। यह प्रदर्शन लॉगिंग को सक्षम करके किया जा सकता है।

LoggingPreferences logPrefs = new LoggingPreferences();
logPrefs.enable(LogType.PERFORMANCE, Level.ALL);
cap.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);

अनुरोध पूरा हो जाने के बाद, आपको बस इतना करना है और इत्र लॉग को पुन: व्यवस्थित करें और अनुरोधित यूआरएल के लिए "Network.responseReceived" ढूंढें:

LogEntries logs = driver.manage().logs().get("performance");

यहाँ कोड है:

import java.util.Iterator;
import java.util.logging.Level;

import org.json.JSONException;
import org.json.JSONObject;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.logging.LogEntries;
import org.openqa.selenium.logging.LogEntry;
import org.openqa.selenium.logging.LogType;
import org.openqa.selenium.logging.LoggingPreferences;
import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;

public class TestResponseCode
{
    public static void main(String[] args)
    {
        // simple page (without many resources so that the output is
        // easy to understand
        String url = "http://www.york.ac.uk/teaching/cws/wws/webpage1.html";

        DownloadPage(url);
    }

    private static void DownloadPage(String url)
    {
        ChromeDriver driver = null;

        try
        {
            ChromeOptions options = new ChromeOptions();
            // add whatever extensions you need
            // for example I needed one of adding proxy, and one for blocking
            // images
            // options.addExtensions(new File(file, "proxy.zip"));
            // options.addExtensions(new File("extensions",
            // "Block-image_v1.1.crx"));

            DesiredCapabilities cap = DesiredCapabilities.chrome();
            cap.setCapability(ChromeOptions.CAPABILITY, options);

            // set performance logger
            // this sends Network.enable to chromedriver
            LoggingPreferences logPrefs = new LoggingPreferences();
            logPrefs.enable(LogType.PERFORMANCE, Level.ALL);
            cap.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);

            driver = new ChromeDriver(cap);

            // navigate to the page
            System.out.println("Navigate to " + url);
            driver.navigate().to(url);

            // and capture the last recorded url (it may be a redirect, or the
            // original url)
            String currentURL = driver.getCurrentUrl();

            // then ask for all the performance logs from this request
            // one of them will contain the Network.responseReceived method
            // and we shall find the "last recorded url" response
            LogEntries logs = driver.manage().logs().get("performance");

            int status = -1;

            System.out.println("\nList of log entries:\n");

            for (Iterator<LogEntry> it = logs.iterator(); it.hasNext();)
            {
                LogEntry entry = it.next();

                try
                {
                    JSONObject json = new JSONObject(entry.getMessage());

                    System.out.println(json.toString());

                    JSONObject message = json.getJSONObject("message");
                    String method = message.getString("method");

                    if (method != null
                            && "Network.responseReceived".equals(method))
                    {
                        JSONObject params = message.getJSONObject("params");

                        JSONObject response = params.getJSONObject("response");
                        String messageUrl = response.getString("url");

                        if (currentURL.equals(messageUrl))
                        {
                            status = response.getInt("status");

                            System.out.println(
                                    "---------- bingo !!!!!!!!!!!!!! returned response for "
                                            + messageUrl + ": " + status);

                            System.out.println(
                                    "---------- bingo !!!!!!!!!!!!!! headers: "
                                            + response.get("headers"));
                        }
                    }
                } catch (JSONException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            System.out.println("\nstatus code: " + status);
        } finally
        {
            if (driver != null)
            {
                driver.quit();
            }
        }
    }
}

आउटपुट इस तरह दिखता है:

    Navigate to http://www.york.ac.uk/teaching/cws/wws/webpage1.html

    List of log entries:

    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameAttached","params":{"parentFrameId":"172.1","frameId":"172.2"}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameStartedLoading","params":{"frameId":"172.2"}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameNavigated","params":{"frame":{"securityOrigin":"://","loaderId":"172.1","name":"chromedriver dummy frame","id":"172.2","mimeType":"text/html","parentId":"172.1","url":"about:blank"}}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameStoppedLoading","params":{"frameId":"172.2"}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameStartedLoading","params":{"frameId":"3928.1"}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Network.requestWillBeSent","params":{"request":{"headers":{"Upgrade-Insecure-Requests":"1","User-Agent":"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36"},"initialPriority":"VeryHigh","method":"GET","mixedContentType":"none","url":"http://www.york.ac.uk/teaching/cws/wws/webpage1.html"},"frameId":"3928.1","requestId":"3928.1","documentURL":"http://www.york.ac.uk/teaching/cws/wws/webpage1.html","initiator":{"type":"other"},"loaderId":"3928.1","wallTime":1.47619492749007E9,"type":"Document","timestamp":20226.652971}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Network.responseReceived","params":{"frameId":"3928.1","requestId":"3928.1","response":{"headers":{"Accept-Ranges":"bytes","Keep-Alive":"timeout=4, max=100","Cache-Control":"max-age=300","Server":"Apache/2.2.22 (Ubuntu)","Connection":"Keep-Alive","Content-Encoding":"gzip","Vary":"Accept-Encoding","Expires":"Tue, 11 Oct 2016 14:13:47 GMT","Content-Length":"1957","Date":"Tue, 11 Oct 2016 14:08:47 GMT","Content-Type":"text/html"},"connectionReused":false,"timing":{"pushEnd":0,"workerStart":-1,"proxyEnd":-1,"workerReady":-1,"sslEnd":-1,"pushStart":0,"requestTime":20226.65335,"sslStart":-1,"dnsStart":0,"sendEnd":31.6569999995409,"connectEnd":31.4990000006219,"connectStart":0,"sendStart":31.5860000009707,"dnsEnd":0,"receiveHeadersEnd":115.645999998378,"proxyStart":-1},"encodedDataLength":-1,"remotePort":80,"mimeType":"text/html","headersText":"HTTP/1.1 200 OK\r\nDate: Tue, 11 Oct 2016 14:08:47 GMT\r\nServer: Apache/2.2.22 (Ubuntu)\r\nAccept-Ranges: bytes\r\nCache-Control: max-age=300\r\nExpires: Tue, 11 Oct 2016 14:13:47 GMT\r\nVary: Accept-Encoding\r\nContent-Encoding: gzip\r\nContent-Length: 1957\r\nKeep-Alive: timeout=4, max=100\r\nConnection: Keep-Alive\r\nContent-Type: text/html\r\n\r\n","securityState":"neutral","requestHeadersText":"GET /teaching/cws/wws/webpage1.html HTTP/1.1\r\nHost: www.york.ac.uk\r\nConnection: keep-alive\r\nUpgrade-Insecure-Requests: 1\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n","url":"http://www.york.ac.uk/teaching/cws/wws/webpage1.html","protocol":"http/1.1","fromDiskCache":false,"fromServiceWorker":false,"requestHeaders":{"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8","Upgrade-Insecure-Requests":"1","Connection":"keep-alive","User-Agent":"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36","Host":"www.york.ac.uk","Accept-Encoding":"gzip, deflate, sdch","Accept-Language":"en-GB,en-US;q=0.8,en;q=0.6"},"remoteIPAddress":"144.32.128.84","statusText":"OK","connectionId":11,"status":200},"loaderId":"3928.1","type":"Document","timestamp":20226.770012}}}
    ---------- bingo !!!!!!!!!!!!!! returned response for http://www.york.ac.uk/teaching/cws/wws/webpage1.html: 200
    ---------- bingo !!!!!!!!!!!!!! headers: {"Accept-Ranges":"bytes","Keep-Alive":"timeout=4, max=100","Cache-Control":"max-age=300","Server":"Apache/2.2.22 (Ubuntu)","Connection":"Keep-Alive","Content-Encoding":"gzip","Vary":"Accept-Encoding","Expires":"Tue, 11 Oct 2016 14:13:47 GMT","Content-Length":"1957","Date":"Tue, 11 Oct 2016 14:08:47 GMT","Content-Type":"text/html"}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Network.dataReceived","params":{"dataLength":2111,"requestId":"3928.1","encodedDataLength":1460,"timestamp":20226.770425}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameNavigated","params":{"frame":{"securityOrigin":"http://www.york.ac.uk","loaderId":"3928.1","id":"3928.1","mimeType":"text/html","url":"http://www.york.ac.uk/teaching/cws/wws/webpage1.html"}}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Network.dataReceived","params":{"dataLength":1943,"requestId":"3928.1","encodedDataLength":825,"timestamp":20226.782673}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Network.loadingFinished","params":{"requestId":"3928.1","encodedDataLength":2285,"timestamp":20226.770199}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.loadEventFired","params":{"timestamp":20226.799391}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.frameStoppedLoading","params":{"frameId":"3928.1"}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Page.domContentEventFired","params":{"timestamp":20226.845769}}}
    {"webview":"3b8eaedb-bd0f-4baa-938d-4aee4039abfe","message":{"method":"Network.requestWillBeSent","params":{"request":{"headers":{"Referer":"http://www.york.ac.uk/teaching/cws/wws/webpage1.html","User-Agent":"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36"},"initialPriority":"High","method":"GET","mixedContentType":"none","url":"http://www.york.ac.uk/favicon.ico"},"frameId":"3928.1","requestId":"3928.2","documentURL":"http://www.york.ac.uk/teaching/cws/wws/webpage1.html","initiator":{"type":"other"},"loaderId":"3928.1","wallTime":1.47619492768527E9,"type":"Other","timestamp":20226.848174}}}

    status code: 200

java + Selenium + Firefox मैंने आख़िरकार फ़ायरफ़ॉक्स के लिए ट्रिक भी ढूंढ ली है। आपको फ़ायरफ़ॉक्स MOZ_LOGऔर MOZ_LOG_FILEपर्यावरण चर का उपयोग करके फ़ायरफ़ॉक्स शुरू करने और डिबग स्तर पर http अनुरोधों को लॉग इन करने की आवश्यकता है (4 = PR_LOG_DEBUG) - map.put("MOZ_LOG", "timestamp,sync,nsHttp:4")। अस्थायी फ़ाइल में लॉग सहेजें। उसके बाद, सहेजे गए लॉग फ़ाइल की सामग्री प्राप्त करें और इसे प्रतिक्रिया कोड के लिए पार्स करें (कुछ सरल नियमित अभिव्यक्तियों का उपयोग करके)। पहले अनुरोध की शुरुआत का पता लगाएं, इसकी आईडी की पहचान करें (nsHttpChannel::BeginConnect [this=000000CED8094000]), फिर दूसरे चरण में, उस अनुरोध आईडी के लिए प्रतिक्रिया कोड ढूंढें (nsHttpChannel::ProcessResponse [this=000000CED8094000 httpStatus=200])।

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.firefox.GeckoDriverService;

public class TestFirefoxResponse
{
  public static void main(String[] args)
      throws InterruptedException, IOException
  {
    GeckoDriverService service = null;

    // tell firefox to log http requests
    // at level 4 = PR_LOG_DEBUG: debug messages, notices
    // you could log everything at level 5, but the log file will 
    // be larger. 
    // create a temporary log file that will be parsed for
    // response code
    Map<String, String> map = new HashMap<String, String>();
    map.put("MOZ_LOG", "timestamp,sync,nsHttp:4");
    File tempFile = File.createTempFile("mozLog", ".txt");    
    map.put("MOZ_LOG_FILE", tempFile.getAbsolutePath());      

    GeckoDriverService.Builder builder = new GeckoDriverService.Builder();
    service = builder.usingAnyFreePort()
      .withEnvironment(map)
      .build();

    service.start();      

    WebDriver driver = new FirefoxDriver(service);

    // test 200
     String url = "https://api.ipify.org/?format=text";
    // test 404
    // String url = "https://www.advancedwebranking.com/lsdkjflksdjfldksfj";
    driver.get(url);

    driver.quit();

    String logContent = FileUtils.readFileToString(tempFile);

    ParseLog(logContent, url);
  }

  private static void ParseLog(String logContent, String url) throws MalformedURLException
  {
    // this is how the log looks like when the request starts
    // I have to get the id of the request using a regular expression
    // and use that id later to get the response
    //
    //    2017-11-02 14:14:01.170000 UTC - [Main Thread]: D/nsHttp nsHttpChannel::BeginConnect [this=000000BFF27A5000]
    //    2017-11-02 14:14:01.170000 UTC - [Main Thread]: D/nsHttp host=api.ipify.org port=-1
    //    2017-11-02 14:14:01.170000 UTC - [Main Thread]: D/nsHttp uri=https://api.ipify.org/?format=text
    String pattern = "BeginConnect \\[this=(.*?)\\](?:.*?)uri=(.*?)\\s";

    Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    Matcher m = p.matcher(logContent);

    String urlID = null;
    while (m.find())
    {
      String id = m.group(1);
      String uri = m.group(2);

      if (uri.equals(url))
      {
        urlID = id;
        break;
      }      
    }

    System.out.println("request id = " + urlID);

    // this is how the response looks like in the log file
    // ProcessResponse [this=000000CED8094000 httpStatus=200]
    // I will use another regular espression to get the httpStatus
    //
    //    2017-11-02 14:45:39.296000 UTC - [Main Thread]: D/nsHttp nsHttpChannel::OnStartRequest [this=000000CED8094000 request=000000CED8014BB0 status=0]
    //    2017-11-02 14:45:39.296000 UTC - [Main Thread]: D/nsHttp nsHttpChannel::ProcessResponse [this=000000CED8094000 httpStatus=200]    

    pattern = "ProcessResponse \\[this=" + urlID + " httpStatus=(.*?)\\]";

    p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    m = p.matcher(logContent);

    if (m.find())
    {
      String responseCode = m.group(1);
      System.out.println("response code found " + responseCode);
    }
    else
    {
      System.out.println("response code not found");
    }
  }
}

इसके लिए आउटपुट होगा

अनुरोध आईडी = 0000007653D67000 प्रतिक्रिया कोड 200 मिला

प्रतिक्रिया शीर्षकों को लॉग फ़ाइल में भी पाया जा सकता है। आप चाहें तो उन्हें प्राप्त कर सकते हैं।

    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp http response [
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   HTTP/1.1 404 Not Found
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Accept-Ranges: bytes
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Cache-control: no-cache="set-cookie"
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Content-Type: text/html; charset=utf-8
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Date: Thu, 02 Nov 2017 14:54:36 GMT
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   ETag: "7969-55bc076a61e80"
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Last-Modified: Tue, 17 Oct 2017 16:17:46 GMT
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Server: Apache/2.4.23 (Amazon) PHP/5.6.24
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Set-Cookie: AWSELB=5F256FFA816C8E72E13AE0B12A17A3D540582F804C87C5FEE323AF3C9B638FD6260FF473FF64E44926DD26221AAD2E9727FD739483E7E4C31784C7A495796B416146EE83;PATH=/
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Content-Length: 31081
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Connection: keep-alive
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp     OriginalHeaders
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Accept-Ranges: bytes
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Cache-control: no-cache="set-cookie"
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Content-Type: text/html; charset=utf-8
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Date: Thu, 02 Nov 2017 14:54:36 GMT
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   ETag: "7969-55bc076a61e80"
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Last-Modified: Tue, 17 Oct 2017 16:17:46 GMT
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Server: Apache/2.4.23 (Amazon) PHP/5.6.24
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Set-Cookie: AWSELB=5F256FFA816C8E72E13AE0B12A17A3D540582F804C87C5FEE323AF3C9B638FD6260FF473FF64E44926DD26221AAD2E9727FD739483E7E4C31784C7A495796B416146EE83;PATH=/
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Content-Length: 31081
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp   Connection: keep-alive
    2017-11-02 14:54:36.775000 UTC - [Socket Thread]: I/nsHttp ]
    2017-11-02 14:54:36.775000 UTC - [Main Thread]: D/nsHttp nsHttpChannel::OnStartRequest [this=0000008A65D85000 request=0000008A65D1F900 status=0]
    2017-11-02 14:54:36.775000 UTC - [Main Thread]: D/nsHttp nsHttpChannel::ProcessResponse [this=0000008A65D85000 httpStatus=404]

Comments

इसे देखने वाले लोगों के लिए, ध्यान रखें कि क्रोमियम का network.enable हर HTTP अनुरोध में एक अतिरिक्त शीर्षलेख सम्मिलित करता है, जबकि यह सक्षम है।

— फेक नेम

नमस्ते, मैं प्रतिक्रिया कोड प्राप्त करने में सक्षम हूं, लेकिन मुझे प्रतिक्रिया निकाय कैसे मिल सकता है? मैं इसे प्रतिक्रिया में नहीं देख रहा हूँ JSONObject।

— lings

@Lings आप Driver.getPageSource () का उपयोग कर सकते हैं, लेकिन ध्यान से रहें क्योंकि आमतौर पर कई जावास्क्रिप्ट जावास्क्रिप्ट अनुरोध होते हैं जो डोम को बदल सकते हैं। आप डोम में मौजूद होने के लिए अपने पेज के कुछ तत्व की प्रतीक्षा कर सकते हैं और फिर पेज सोर्स प्राप्त कर सकते हैं। एक और परिदृश्य फ्रेम के साथ है। यदि आपके पास फ़्रेम हैं, तो आपको फ़्रेम पर स्विच करना होगा, फिर उस फ़्रेम का स्रोत कोड प्राप्त करें - driver.switchTo ()। फ़्रेम ();

— स्टीफन मैटी

मैंने आपके कोड को RemoteWebDriver के साथ लागू करने की कोशिश की , क्योंकि मेरे तरीके RemoteWebdriver के साथ लिखे गए हैं। क्या आपके पास रिमोटवेबड्राइवर के साथ इसका उपयोग करने के बारे में कोई विचार है ?

— M3trix 10

@IvayloSlavov क्रोम स्क्रिप्ट मेरे लिए 4.0.0-अल्फा -4 के साथ काम करती है, कृपया इस उदाहरण को देखें github.com/smatei/SeleniumChromeHTTPResponse

— स्टीफन मेटी

Answer 3

आप अनुरोधों और प्रतिक्रियाओं को कैप्चर करने के लिए BrowserMob प्रॉक्सी का उपयोग कर सकते हैं HttpRequestInterceptor। यहाँ जावा में एक उदाहरण है:

// Start the BrowserMob proxy
ProxyServer server = new ProxyServer(9978);
server.start();

server.addResponseInterceptor(new HttpResponseInterceptor()
{
    @Override
    public void process(HttpResponse response, HttpContext context)
        throws HttpException, IOException
    {
        System.out.println(response.getStatusLine());
    }
});

// Get selenium proxy
Proxy proxy = server.seleniumProxy();

// Configure desired capability for using proxy server with WebDriver
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(CapabilityType.PROXY, proxy);

// Set up driver
WebDriver driver = new FirefoxDriver(capabilities);

driver.get("http://stackoverflow.com/questions/6509628/webdriver-get-http-response-code");

// Close the browser
driver.quit();

Comments

मैं आपके समाधान का उपयोग कर रहा हूं लेकिन प्रॉक्सी के साथ पृष्ठ लोड बहुत धीमा है। किसी भी विचार यह कैसे आता है? मेरा प्रश्न भी देखें: stackoverflow.com/questions/21043928/…

— चार्ली

मूल BrowserMob प्रॉक्सी अब असमर्थित और बिट रोटेटिंग है। हमारे पास ब्रॉसमेरब प्रॉक्सी का एक खुला स्रोत कांटा है जिसमें अंतर्निहित प्रदर्शन, पृष्ठ और नेटवर्क दावे भी हैं। github.com/browserup/browserup-proxy

— ebland

Answer 4

उन लोगों के लिए जो पायथन का उपयोग कर रहे हैं, आप सेलेनियम वायर पर विचार कर सकते हैं , एक पुस्तकालय जिसे मैंने परीक्षण के दौरान ब्राउज़र द्वारा किए गए अनुरोधों के निरीक्षण के लिए विकसित किया था।

आपको driver.requestsविशेषता के माध्यम से अनुरोधों तक पहुंच प्राप्त होती है :

from seleniumwire import webdriver  # Import from seleniumwire

# Create a new instance of the Firefox driver
driver = webdriver.Firefox()

# Go to the Google home page
driver.get('https://www.google.com')

# Access requests via the `requests` attribute
for request in driver.requests:
    if request.response:
        print(
            request.url,
            request.response.status_code,
            request.response.headers['Content-Type']
        )

प्रिंटों:

https://www.google.com/ 200 text/html; charset=UTF-8
https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_120x44dp.png 200 image/png
https://consent.google.com/status?continue=https://www.google.com&pc=s&timestamp=1531511954&gl=GB 204 text/html; charset=utf-8
https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png 200 image/png
https://ssl.gstatic.com/gb/images/i2_2ec824b0.png 200 image/png
https://www.google.com/gen_204?s=webaft&t=aft&atyp=csi&ei=kgRJW7DBONKTlwTK77wQ&rt=wsrt.366,aft.58,prt.58 204 text/html; charset=UTF-8
...

लाइब्रेरी आपको हेडर, स्टेटस कोड, बॉडी कंटेंट एक्सेस करने की क्षमता, साथ ही हेडर को संशोधित करने और यूआरएल को फिर से लिखने की सुविधा देती है।

Comments

मैं कोशिश कर रहा हूँ webdriver.emote के साथ इस का उपयोग करें, लेकिन मुझे "AttractError: 'WebDriver' ऑब्जेक्ट में कोई विशेषता 'अनुरोध' नहीं है" क्या यह इसलिए है क्योंकि रिमोट ड्राइवर सेलेनियम-वायर द्वारा समर्थित नहीं है? आधिकारिक दस्तावेज में निराशाजनक रूप से कमी है। धन्यवाद!

— लेन्नर्ट रोलैंड

@ सेलेनियम वायर की सीमाओं में से एक लेनार्टरॉलैंड यह है कि यह केवल उसी मशीन पर काम करेगा जो ब्राउज़र चला रहा है। वर्तमान में दूरस्थ सेटअप का उपयोग करना समर्थित नहीं है।

— विल कीलिंग

@MohamedImran यदि आप एक विशिष्ट प्रतिक्रिया में रुचि रखते हैं तो आप driver.wait_for_request()अनुरोध का पता लगाने के लिए विधि का उपयोग कर सकते हैं जिसकी प्रतिक्रिया में आप रुचि रखते हैं। अधिक जानकारी के लिए डॉक्स देखें ।

— विल किलिंग

@MohamedImran विधि एक rexx लेती है, इसलिए आप URL के केवल उस भाग को पारित कर सकते हैं जो विशिष्ट रूप से मेल खाता है। उदाहरण के लिए http://myserver.com/some/path/12345/आप पास कर सकते हैंdriver.wait_for_request(‘.*/12345/‘)

— विल कीलिंग

@MohamedImran के लिए आपको लूप की आवश्यकता नहीं है

— विल किलिंग

Answer 5

मैं भी एक ही मुद्दा रहा था और कुछ दिनों के लिए अटक गया था, लेकिन कुछ शोध के बाद मुझे पता चला कि हम सेलेनियम वेब ड्राइवर के साथ संयोजन के रूप में अनुरोधों को बाधित करने के लिए वास्तव में क्रोम के "- -मोटोटे-डिबगिंग-पोर्ट" का उपयोग कर सकते हैं। Pseudocode को संदर्भ के रूप में प्रयोग करें: -

रिमोट डिबगिंग के साथ क्रोम चालक का उदाहरण बनाएं

int freePort = findFreePort();

chromeOptions.addArguments("--remote-debugging-port=" + freePort);

ChromeDriver driver = new ChromeDriver(chromeOptions);`

http://127.0.0.1:freePort पर कॉल करें

String response = makeGetCall( "http://127.0.0.1" + freePort  + "/json" );

निकालने के लिए क्रोम के वेब सॉकेट Url को सुनें, आप प्रतिक्रिया देख सकते हैं और पता लगा सकते हैं कि कैसे निकालना है

String webSocketUrl = response.substring(response.indexOf("ws://127.0.0.1"), response.length() - 4);

इस सॉकेट से कनेक्ट करें, यू asyncHttp का उपयोग कर सकता है

socket = maketSocketConnection( webSocketUrl );

नेटवर्क कैप्चर सक्षम करें

socket.send( { "id" : 1, "method" : "Network.enable" } );

अब क्रोम सभी नेटवर्क से संबंधित घटनाओं को भेजेगा और उन्हें निम्नानुसार कैप्चर करेगा

socket.onMessageReceived( String message ){

    Json responseJson = toJson(message);
    if( responseJson.method == "Network.responseReceived" ){
       //extract status code
    }
}

driver.get("http://stackoverflow.com");

आप देव उपकरण साइट में उल्लिखित सब कुछ कर सकते हैं। देख https://chromedevtools.github.io/devtools-protocol/ नोट : - 2.39 या इसके बाद के संस्करण का उपयोग करें।

मुझे उम्मीद है कि यह किसी की मदद करता है।

संदर्भ: Google Chrome दूरस्थ डिबगिंग प्रोटोकॉल का उपयोग करना

Comments

बहुत बढ़िया, मुझे खुशी है कि ऐसा करने का एक तरीका है! मेरी इच्छा है कि एक पुस्तकालय (रूबी के लिए selenium-webdriver, मेरे मामले में) स्वचालित रूप से सक्षम हो गया Network.enableऔर अंतिम प्रतिक्रिया की जांच करने का एक सरल तरीका उजागर हुआ ... जैसे driver.response.status_code। हो सकता है कि किसी दिन मैं इसे जोड़ने के लिए मिल

— टायलर रिक

यदि कोई अन्य रूबी प्रोग्रामर इस पर आता है, तो मैंने एक मणि बनाया, github.com/TylerRick/capybara-chrome_response_headers , जिससे आप आसानी से केवल कॉल करके कैपेबेल / RSpec परीक्षण से HTTP स्थिति कोड प्राप्त कर सकते हैं status_code। यह इस उदाहरण की तरह क्रोम रिमोट डीबगिंग प्रोटोकॉल का उपयोग करता है।

— टायलर रिक

धन्यवाद यू दोस्त! मेरे लिए chrome 76 + सेलेनियम 3.141

— jessez

Answer 6

किसी भी भाषा में प्रतिक्रिया कोड प्राप्त करें (जावास्क्रिप्ट का उपयोग करके):

यदि आपका सेलेनियम परीक्षण आधुनिक ब्राउज़र में चलता है, तो प्रतिक्रिया कोड प्राप्त करने का एक आसान तरीका एक तुल्यकालिक XMLHttpRequest* भेजना है और statusप्रतिक्रिया की जांच करना है:

var xhr = new XMLHttpRequest();
xhr.open('GET', 'http://exampleurl.ex', false);
xhr.send(null);

assert(200, xhr.status);

आप किसी भी प्रोग्रामिंग भाषा के साथ इस तकनीक का उपयोग करके अनुरोध कर सकते हैं कि सेलेनियम स्क्रिप्ट निष्पादित करें। उदाहरण के लिए, जावा में आप JavascriptExecutor.executeScript()भेजने के लिए उपयोग कर सकते हैं XMLHttpRequest:

final String GET_RESPONSE_CODE_SCRIPT =
    "var xhr = new XMLHttpRequest();" +
    "xhr.open('GET', arguments[0], false);" +
    "xhr.send(null);" +
    "return xhr.status";
JavascriptExecutor javascriptExecutor = (JavascriptExecutor) webDriver;
Assert.assertEquals(200,
    javascriptExecutor.executeScript(GET_RESPONSE_CODE_SCRIPT, "http://exampleurl.ex"));

* आप XMLHttpRequestइसके बजाय एक एसिंक्रोनस भेज सकते हैं , लेकिन आपको अपना परीक्षण जारी रखने से पहले इसे पूरा करने के लिए इंतजार करना होगा।

जावा में प्रतिक्रिया कोड प्राप्त करें:

आप का उपयोग करके जावा में प्रतिक्रिया कोड प्राप्त कर सकते हैं URL.openConnection()और HttpURLConnection.getResponseCode():

URL url = new URL("http://exampleurl.ex");
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setRequestMethod("GET");

// You may need to copy over the cookies that Selenium has in order
// to imitate the Selenium user (for example if you are testing a
// website that requires a sign-in).
Set<Cookie> cookies = webDriver.manage().getCookies();
String cookieString = "";

for (Cookie cookie : cookies) {
    cookieString += cookie.getName() + "=" + cookie.getValue() + ";";
}

httpURLConnection.addRequestProperty("Cookie", cookieString);
Assert.assertEquals(200, httpURLConnection.getResponseCode());

इस पद्धति को शायद अन्य भाषाओं के लिए भी सामान्यीकृत किया जा सकता है, लेकिन भाषा के (या पुस्तकालय के) एपीआई को फिट करने के लिए संशोधित करने की आवश्यकता होगी।

Answer 7

यह सुनिश्चित नहीं करें कि आप क्या देख रहे हैं, लेकिन मेरे पास एक अलग लक्ष्य था यह जांचने के लिए कि क्या दूरस्थ छवि मौजूद है और मेरे पास 403 त्रुटि नहीं होगी, इसलिए आप नीचे कुछ का उपयोग कर सकते हैं:

public static boolean linkExists(String URLName){
    try {
        HttpURLConnection.setFollowRedirects(false);
        HttpURLConnection con = (HttpURLConnection) new URL(URLName).openConnection();
        con.setRequestMethod("HEAD");
        return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
    }
    catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

Comments

सरल मामलों के लिए आसान, लेकिन आपके पास इस विधि (जैसे उपयोगकर्ता लॉगिन) का उपयोग करके कोई ब्राउज़र स्थिति नहीं है।

— रोजर कीस

मेरा मानना ​​है कि आप हेडर अनुरोध के हिस्से के रूप में क्रेडेंशियल्स भेज सकते हैं, अगर आप कोशिश कर सकते हैं तो मैं सराहना करूंगा।

— वलोडिमिर प्रिसिआज़निएक

Answer 8

सीधे सेलेनियम वेबड्राइवर का उपयोग करके HTTP रिस्पांस कोड प्राप्त करना संभव नहीं है। जावा कोड का उपयोग करके कोड प्राप्त किया जा सकता है और इसका उपयोग सेलेनियम वेबड्राइवर में किया जा सकता है।

जावा द्वारा HTTP रिस्पांस कोड प्राप्त करने के लिए:

public static int getResponseCode(String urlString) throws MalformedURLException, IOException{
    URL url = new URL(urlString);
    HttpURLConnection huc = (HttpURLConnection)url.openConnection();
    huc.setRequestMethod("GET");
    huc.connect();
    return huc.getResponseCode();
}

अब आप नीचे अपना सेलेनियम वेबड्राइवर कोड लिख सकते हैं:

private static int statusCode;
public static void main(String... args) throws IOException{
    WebDriver driver = new FirefoxDriver();
    driver.manage().window().maximize();
    driver.get("https://www.google.com/");
    driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

    List<WebElement> links = driver.findElements(By.tagName("a"));
    for(int i = 0; i < links.size(); i++){
        if(!(links.get(i).getAttribute("href") == null) && !(links.get(i).getAttribute("href").equals(""))){
            if(links.get(i).getAttribute("href").contains("http")){
                statusCode= getResponseCode(links.get(i).getAttribute("href").trim());
                if(statusCode == 403){
                    System.out.println("HTTP 403 Forbidden # " + i + " " + links.get(i).getAttribute("href"));
                }
            }
        }   
    }   
}

Comments

क्या होगा अगर यह एक POST फॉर्म सबमिट था? अगर कुकीज़ हैं तो क्या होगा?

— 22

यह सिर्फ सेलेनियम के बाहर एक HTTP अनुरोध भेज रहा है।

— मथायस विंकेलमैन

Answer 9

आप Mobilenium ( https://github.com/rafpyprog/Mobilenium ), एक अजगर पैकेज की कोशिश कर सकते हैं जो BrowserMob प्रॉक्सी और सेलेनियम को बांधता है।

एक उपयोग उदाहरण:

>>> from mobilenium import mobidriver
>>>
>>> browsermob_path = 'path/to/browsermob-proxy'
>>> mob = mobidriver.Firefox(browsermob_binary=browsermob_path)
>>> mob.get('http://python-requests.org')
301
>>> mob.response['redirectURL']
'http://docs.python-requests.org'
>>> mob.headers['Content-Type']
'application/json; charset=utf8'
>>> mob.title
'Requests: HTTP for Humans \u2014 Requests 2.13.0 documentation'
>>> mob.find_elements_by_tag_name('strong')[1].text
'Behold, the power of Requests'