net.lightbody.bmp.filters.RequestFilter Java Examples

@CheckedProvides(IOURIProvider.class)
public ProxyDriverIntegrator getProxyDriverIntegrator(IOProvider<RequestFilter> requestFilterIOProvider,
                                                      IOProvider<ResponseFilter> responseFilterIOURIProvider,
                                                      WebDriverSupplier webDriverSupplier,
                                                      DriverServiceSupplier driverServiceSupplier,
                                                      @Named(PATH_TO_DRIVER) String pathToDriverExecutable,
                                                      @Named(SCREEN) String screen,
                                                      @Named(TIMEOUT) int timeout) throws IOException, URISyntaxException {
    return getProxyDriverIntegrator(requestFilterIOProvider.get(),
            webDriverSupplier,
            driverServiceSupplier,
            pathToDriverExecutable,
            screen,
            timeout,
            responseFilterIOURIProvider.get());
}
 

private ProxyDriverIntegrator getProxyDriverIntegrator(RequestFilter recordRequestFilter,
                                                       WebDriverSupplier webDriverSupplier,
                                                       DriverServiceSupplier driverServiceSupplier,
                                                       @Named(PATH_TO_DRIVER) String pathToDriverExecutable,
                                                       @Named(SCREEN) String screen,
                                                       @Named(TIMEOUT) int timeout,
                                                       ResponseFilter responseFilter) throws IOException {
    BrowserMobProxy proxy = createBrowserMobProxy(timeout, recordRequestFilter, responseFilter);
    proxy.start(0);
    logger.info("Proxy running on port " + proxy.getPort());
    Proxy seleniumProxy = createSeleniumProxy(proxy);
    DesiredCapabilities desiredCapabilities = createDesiredCapabilities(seleniumProxy);
    DriverService driverService = driverServiceSupplier.getDriverService(pathToDriverExecutable, screen);
    WebDriver driver = webDriverSupplier.get(driverService, desiredCapabilities);

    return new ProxyDriverIntegrator(driver, proxy, driverService);
}
 

@Test
public void ifCommmandIsInvalidExceptionIsThrown() throws IOException {
    String command = "invalid";
    Map<String, Object> opts = new HashMap<>();
    opts.put(BROWSER, CHROME);
    opts.put(DRIVER, chromedriverFile.getAbsolutePath());
    opts.put(APPLICATION, configurationFile.getAbsolutePath());
    opts.put(URL, localhostUrl);
    opts.put(CASE, caseFile.getAbsolutePath());
    opts.put(SCREEN, screenString);
    opts.put(TIMEOUT, timeoutString);
    opts.put(PRECISION, precisionString);
    Module module = new DefaultModule(command, opts);
    Injector injector = Guice.createInjector(module);

    try {
        RequestFilter instance = injector.getInstance(
                Key.get(new TypeLiteral<IOProvider<RequestFilter>>() {})).get();
    } catch (ProvisionException e) {
        assertTrue(e.getCause() instanceof NoSuchCommandException);
    }
}
 

@CheckedProvides(IOProvider.class)
public RequestFilter getRequestFilter(@Named(COMMAND) String command,
                                      IOProvider<List<EventDetector>> eventDetectorListProvider,
                                      Provider<RecordingState> recordingStateProvider,
                                      Provider<ReplayingState> replayingStateProvider,
                                      Provider<List<ConditionsUpdater>> conditionsUpdaters) throws IOException {
    switch (command) {
        case RECORD:
            return new RecordRequestFilter(recordingStateProvider.get(), eventDetectorListProvider.get());
        case REPLAY:
            return new ReplayRequestFilter(replayingStateProvider.get(), conditionsUpdaters.get());
        default:
            throw new NoSuchCommandException();
    }
}
 

public BrowserMobProxy createBrowserMobProxy(int timeout, RequestFilter requestFilter, ResponseFilter responseFilter) {
    BrowserMobProxyServer proxy = new BrowserMobProxyServer();
    proxy.enableHarCaptureTypes(CaptureType.REQUEST_CONTENT, CaptureType.RESPONSE_CONTENT);
    proxy.newHar("measurements");
    proxy.addRequestFilter(requestFilter);
    proxy.addResponseFilter(responseFilter);
    proxy.setIdleConnectionTimeout(timeout, TimeUnit.SECONDS);
    proxy.setRequestTimeout(timeout, TimeUnit.SECONDS);
    return proxy;
}
 

@SuppressWarnings("unchecked")
public RecordingSimulatorModule(Injector originalInjector) throws IOException {
    this.webDriverSupplier = spy(originalInjector.getInstance(WebDriverSupplier.class));
    this.recordingState = spy(originalInjector.getInstance(RecordingState.class));
    this.promptUtils = spy(originalInjector.getInstance(PromptUtils.class));
    this.recordRequestFilter = spy(originalInjector.getInstance(
            Key.get(new TypeLiteral<IOProvider<RequestFilter>>() {})).get());

    doAnswer(invocationOnMock -> {
        Object driver = invocationOnMock.callRealMethod();
        setWebDriver((WebDriver) driver);
        return driver;
    }).when(webDriverSupplier).get(any(), any());
}
 

@Override
protected void configure() {
    bind(WebDriverSupplier.class).toProvider(() -> webDriverSupplier);
    bind(PromptUtils.class).toProvider(() -> promptUtils);
    bind(RecordingState.class).toProvider(() -> recordingState);
    bind(RequestFilter.class).toProvider(() -> recordRequestFilter);
}
 

@Override
public void run(RecordingSimulatorModule recordingSimulatorModule) {
    RequestFilter recordRequestFilter = recordingSimulatorModule.getRecordRequestFilter();
    HttpMessageContents httpMessageContents = mock(HttpMessageContents.class);
    HttpMessageInfo httpMessageInfo = mock(HttpMessageInfo.class);

    for (Map<String, String> testCaseStep: expected) {
        String queryString = URLUtils.toQueryString(testCaseStep);
        HttpRequest httpRequest = mock(HttpRequest.class, RETURNS_DEEP_STUBS);
        when(httpRequest.getUri()).thenReturn(SUBMIT_EVENT_URL + queryString);
        when(httpRequest.getMethod()).thenReturn(HttpMethod.GET);
        when(httpRequest.headers().get(ACCEPT)).thenReturn(HTML);
        recordRequestFilter.filterRequest(httpRequest, httpMessageContents, httpMessageInfo);
    }
}
 

@Override
public HttpResponse filterRequest(
    HttpRequest httpRequest, HttpMessageContents httpMessageContents, HttpMessageInfo httpMessageInfo) {
  for (RequestFilter requestFilter : filters) {
    HttpResponse response = requestFilter.filterRequest(httpRequest, httpMessageContents, httpMessageInfo);
    if (response != null) {
      return response;
    }
  }
  return null;
}
 

public RequestFilter getRecordRequestFilter() {
    return recordRequestFilter;
}
 

/**
 * Apps like life express will often include AWSELB cookies from both the root "/" context and the
 * application "/life-express" context. Supplying both cookies means that requests are sent to a EC2
 * instance that didn't generate the initial session, and so the request fails. This step allows us to
 * remove these duplicated cookies from the request.
 *
 * @param url The regex that matches URLs that should have duplicate AWSELB cookies removed
 */
@When("^I (?:remove|delete) root AWSELB cookie from the request to the URL regex \"(.*?)\"$")
public void stripHeaders(final String url) {
	final Optional<ProxyDetails<?>> proxy =
		State.getFeatureStateForThread().getProxyInterface(BrowsermobProxyUtilsImpl.PROXY_NAME);

	/*
		Get the name of the thread running the test
	 */
	final String threadName = Thread.currentThread().getName();


	proxy
		.flatMap(ProxyDetails::getInterface)
		.map(BrowserMobProxy.class::cast)
		.ifPresent(x -> {
			x.addRequestFilter(new RequestFilter() {
				@Override
				public HttpResponse filterRequest(
					final HttpRequest request,
					final HttpMessageContents contents,
					final HttpMessageInfo messageInfo) {
					if (messageInfo.getOriginalRequest().getUri().matches(url)) {
						final Optional<String> cookies =
							Optional.ofNullable(request.headers().get("Cookie"));

					/*
						Only proceed if we have supplied some cookies
					 */
						if (cookies.isPresent()) {
						/*
							Find the root context cookie
						 */
							final WebDriver webDriver =
								State
									.getThreadDesiredCapabilityMap()
									.getWebDriverForThread(threadName, true);

							final Optional<Cookie> awselb =
								webDriver.manage().getCookies()
									.stream()
									.filter(x -> "AWSELB".equals(x.getName()))
									.filter(x -> "/".equals(x.getPath()))
									.findFirst();

						/*
							If we have a root context cookie,
							remove it from the request
						 */
							if (awselb.isPresent()) {

								LOGGER.info(
									"WEBAPPTESTER-INFO-0002: "
										+ "Removing AWSELB cookie with value {}",
									awselb.get().getValue());

								final String newCookie =
									cookies.get().replaceAll(awselb.get().getName()
											+ "="
											+ awselb.get().getValue() + ";"
											+ "( "
											+ "GMT=; "
											+ "\\d+-\\w+-\\d+=\\d+:\\d+:\\d+;"
											+ ")?",
										"");

								request.headers().set("Cookie", newCookie);
							}

							final int awsElbCookieCount = StringUtils.countMatches(
								request.headers().get("Cookie"),
								"AWSELB");

							if (awsElbCookieCount != 1) {
								LOGGER.info(
									"WEBAPPTESTER-INFO-0003: "
										+ "{} AWSELB cookies found",
									awsElbCookieCount);
							}
						}

					}

					return null;
				}
			});
		});
}
 

/**
 * Adds a new RequestFilter that can be used to examine and manipulate the request before sending it to the server.
 *
 * @param filter filter instance
 */
void addRequestFilter(RequestFilter filter);
 

/**
 * <b>Note:</b> The current implementation of this method forces a maximum request size of 2 MiB. To adjust the maximum request size, or
 * to disable aggregation (which disallows access to the {@link net.lightbody.bmp.util.HttpMessageContents}), you may add the filter source
 * directly: <code>addFirstHttpFilterFactory(new RequestFilterAdapter.FilterSource(filter, bufferSizeInBytes));</code>
 */
@Override
public void addRequestFilter(RequestFilter filter) {
    addFirstHttpFilterFactory(new RequestFilterAdapter.FilterSource(filter));
}
 

/**
 * <b>Note:</b> The current implementation of this method forces a maximum request size of 2 MiB. To adjust the maximum request size, or
 * to disable aggregation (which disallows access to the {@link net.lightbody.bmp.util.HttpMessageContents}), you may add the filter source
 * directly: <code>addFirstHttpFilterFactory(new RequestFilterAdapter.FilterSource(filter, bufferSizeInBytes));</code>
 */
@Override
public void addRequestFilter(RequestFilter filter) {
    addFirstHttpFilterFactory(new RequestFilterAdapter.FilterSource(filter));
}
 

/**
 * Adds a new RequestFilter that can be used to examine and manipulate the request before sending it to the server.
 *
 * @param filter filter instance
 */
void addRequestFilter(RequestFilter filter);
 

/**
 * <b>Note:</b> The current implementation of this method forces a maximum request size of 2 MiB. To adjust the maximum request size, or
 * to disable aggregation (which disallows access to the {@link net.lightbody.bmp.util.HttpMessageContents}), you may add the filter source
 * directly: <code>addFirstHttpFilterFactory(new RequestFilterAdapter.FilterSource(filter, bufferSizeInBytes));</code>
 */
@Override
public void addRequestFilter(RequestFilter filter) {
    addFirstHttpFilterFactory(new RequestFilterAdapter.FilterSource(filter));
}
 

/**
 * Unregister filter (it won't get anymore events)
 *
 * @param filter filter to be removed to the Set of filters.
 */
public void remove(RequestFilter filter) {
  filters.remove(filter);
}
 

/**
 * Register new filter
 *
 * @param filter filter to be added to the Set of filters.
 */
public void add(RequestFilter filter) {
  filters.add(filter);
}
 

/**
 * Adds a new RequestFilter that can be used to examine and manipulate the request before sending it to the server.
 *
 * @param filter filter instance
 */
void addRequestFilter(RequestFilter filter);