下面列出了io.reactivex.MaybeOnSubscribe#com.gargoylesoftware.htmlunit.WebResponse 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
public void testGetNoProxyVersionedMetadataDefaultLayout()
throws Exception
{
String commonsLangMetadata = "commons-lang/commons-lang/2.1/maven-metadata.xml";
String expectedMetadataContents = "dummy-versioned-metadata";
Path metadataFile = repoRootInternal.resolve(commonsLangMetadata);
Files.createDirectories(metadataFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile( metadataFile, Charset.defaultCharset(), expectedMetadataContents );
//WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/internal/" + commonsLangMetadata );
WebResponse response = getWebResponse( "/repository/internal/" + commonsLangMetadata );
assertResponseOK( response );
assertEquals( "Expected file contents", expectedMetadataContents, response.getContentAsString() );
}
/**
* @throws Exception failure
*/
@Test
public void tableWithoutColgroup() throws Exception {
final String html = HtmlPageTest.STANDARDS_MODE_PREFIX_
+ "<html><head>\n"
+ "</head>\n"
+ "<body>\n"
+ " <table><col width='7'/><col width='1'/><tbody><tr><td>seven</td><td>One</td></tr></tbody></table>\n"
+ "</body></html>";
final WebClient webClient = getWebClient();
final WebResponse webResponse = new StringWebResponse(html, URL_FIRST);
final XHtmlPage page = webClient.getPageCreator().getHtmlParser()
.parseXHtml(webResponse, webClient.getCurrentWindow());
final DomElement col = page.getElementsByTagName("col").get(0);
assertEquals(col.getParentNode().getNodeName(), HtmlTableColumnGroup.TAG_NAME);
}
@Test
public void buildResponseHeaders() throws Exception {
this.response.addHeader("Content-Type", "text/html");
this.response.addHeader("X-Test", "value");
Cookie cookie = new Cookie("cookieA", "valueA");
cookie.setDomain("domain");
cookie.setPath("/path");
cookie.setMaxAge(1800);
cookie.setSecure(true);
cookie.setHttpOnly(true);
this.response.addCookie(cookie);
WebResponse webResponse = this.responseBuilder.build();
List<NameValuePair> responseHeaders = webResponse.getResponseHeaders();
assertThat(responseHeaders.size(), equalTo(3));
NameValuePair header = responseHeaders.get(0);
assertThat(header.getName(), equalTo("Content-Type"));
assertThat(header.getValue(), equalTo("text/html"));
header = responseHeaders.get(1);
assertThat(header.getName(), equalTo("X-Test"));
assertThat(header.getValue(), equalTo("value"));
header = responseHeaders.get(2);
assertThat(header.getName(), equalTo("Set-Cookie"));
assertThat(header.getValue(), startsWith("cookieA=valueA; Path=/path; Domain=domain; Max-Age=1800; Expires="));
assertThat(header.getValue(), endsWith("; Secure; HttpOnly"));
}
@Test
public void testGetFromLastManagedRepositoryReturnOk()
throws Exception
{
String resourceName = "dummy/dummy-last-resource/1.0/dummy-last-resource-1.0.txt";
Path dummyReleasesResourceFile = repoRootLast.resolve( resourceName );
Files.createDirectories(dummyReleasesResourceFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile(dummyReleasesResourceFile, Charset.defaultCharset(), "last");
WebRequest request = new GetMethodWebRequest(
"http://machine.com/repository/" + REPO_GROUP_WITH_VALID_REPOS + "/" + resourceName );
WebResponse response = getServletUnitClient().getResponse( request );
assertResponseOK( response );
assertThat( response.getContentAsString() ).isEqualTo( "last" );
}
@Test
public void testGetNoProxySnapshotArtifactDefaultLayout()
throws Exception
{
String commonsLangJar = "commons-lang/commons-lang/2.1-SNAPSHOT/commons-lang-2.1-SNAPSHOT.jar";
String expectedArtifactContents = "dummy-commons-lang-snapshot-artifact";
Path artifactFile = repoRootInternal.resolve(commonsLangJar);
Files.createDirectories(artifactFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile( artifactFile, Charset.defaultCharset() , expectedArtifactContents);
//WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/internal/" + commonsLangJar );
WebResponse response = getWebResponse( "/repository/internal/" + commonsLangJar );
assertResponseOK( response );
assertEquals( "Expected file contents", expectedArtifactContents, response.getContentAsString() );
}
@Test
public void testGetNoProxySnapshotArtifactLegacyLayoutManagedLegacy()
throws Exception
{
String commonsLangJar = "commons-lang/jars/commons-lang-2.1-SNAPSHOT.jar";
String expectedArtifactContents = "dummy-commons-lang-snapshot-artifact";
Path artifactFile = repoRootLegacy.resolve(commonsLangJar);
Files.createDirectories(artifactFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile(artifactFile, Charset.defaultCharset(), expectedArtifactContents);
WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/legacy/" + commonsLangJar );
WebResponse response = getServletUnitClient().getResponse( request );
assertResponseNotFound( response );
}
private boolean isPreflightAuthorized(final WebResponse preflightResponse) {
final String originHeader = preflightResponse.getResponseHeaderValue(HttpHeader.ACCESS_CONTROL_ALLOW_ORIGIN);
if (!ALLOW_ORIGIN_ALL.equals(originHeader)
&& !webRequest_.getAdditionalHeaders().get(HttpHeader.ORIGIN).equals(originHeader)) {
return false;
}
String headersHeader = preflightResponse.getResponseHeaderValue(HttpHeader.ACCESS_CONTROL_ALLOW_HEADERS);
if (headersHeader == null) {
headersHeader = "";
}
else {
headersHeader = headersHeader.toLowerCase(Locale.ROOT);
}
for (final Entry<String, String> header : webRequest_.getAdditionalHeaders().entrySet()) {
final String key = header.getKey().toLowerCase(Locale.ROOT);
if (isPreflightHeader(key, header.getValue())
&& !headersHeader.contains(key)) {
return false;
}
}
return true;
}
/**
* Loads an XML document from the specified location.
*
* @param xmlSource a string containing a URL that specifies the location of the XML file
* @return true if the load succeeded; false if the load failed
*/
@JsxFunction({FF68, FF60})
public boolean load(final String xmlSource) {
if (async_) {
if (LOG.isDebugEnabled()) {
LOG.debug("XMLDocument.load(): 'async' is true, currently treated as false.");
}
}
try {
final WebWindow ww = getWindow().getWebWindow();
final HtmlPage htmlPage = (HtmlPage) ww.getEnclosedPage();
final WebRequest request = new WebRequest(htmlPage.getFullyQualifiedUrl(xmlSource));
final WebResponse webResponse = ww.getWebClient().loadWebResponse(request);
final XmlPage page = new XmlPage(webResponse, ww, false);
setDomNode(page);
return true;
}
catch (final IOException e) {
if (LOG.isDebugEnabled()) {
LOG.debug("Error parsing XML from '" + xmlSource + "'", e);
}
return false;
}
}
/**
* Saves this content as the specified file.
* @param file the file to save to
* @throws IOException if an IO error occurs
*/
public void saveAs(final File file) throws IOException {
final HtmlPage page = (HtmlPage) getPage();
final WebClient webclient = page.getWebClient();
final URL url = page.getFullyQualifiedUrl(getAttributeDirect(SRC_ATTRIBUTE));
final WebRequest request = new WebRequest(url);
request.setCharset(page.getCharset());
request.setAdditionalHeader(HttpHeader.REFERER, page.getUrl().toExternalForm());
final WebResponse webResponse = webclient.loadWebResponse(request);
try (OutputStream fos = Files.newOutputStream(file.toPath());
InputStream content = webResponse.getContentAsStream()) {
IOUtils.copy(content, fos);
}
}
/**
* Returns the attachment's filename, as suggested by the <tt>Content-Disposition</tt>
* header, or {@code null} if no filename was suggested.
* @return the attachment's suggested filename, or {@code null} if none was suggested
*/
public String getSuggestedFilename() {
final WebResponse response = page_.getWebResponse();
final String disp = response.getResponseHeaderValue(HttpHeader.CONTENT_DISPOSITION);
int start = disp.indexOf("filename=");
if (start == -1) {
return null;
}
start += "filename=".length();
if (start >= disp.length()) {
return null;
}
int end = disp.indexOf(';', start);
if (end == -1) {
end = disp.length();
}
if (disp.charAt(start) == '"' && disp.charAt(end - 1) == '"') {
start++;
end--;
}
return disp.substring(start, end);
}
@org.junit.Test
public void testSwagger() throws Exception {
String url = "https://localhost:" + getIdpHttpsPort() + "/fediz-idp/services/rs/swagger.json";
String user = "alice";
String password = "ecila";
final WebClient webClient = new WebClient();
webClient.getOptions().setUseInsecureSSL(true);
webClient.getCredentialsProvider().setCredentials(
new AuthScope("localhost", Integer.parseInt(getIdpHttpsPort())),
new UsernamePasswordCredentials(user, password));
final UnexpectedPage swaggerPage = webClient.getPage(url);
WebResponse response = swaggerPage.getWebResponse();
Assert.assertEquals("application/json", response.getContentType());
String json = response.getContentAsString();
Assert.assertTrue(json.contains("Claims"));
webClient.close();
}
/**
* <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
*
* If the linked content is not already downloaded it triggers a download. Then it stores the response
* for later use.<br>
*
* @param downloadIfNeeded indicates if a request should be performed this hasn't been done previously
* @param request the request; if null getWebRequest() is called to create one
* @return {@code null} if no download should be performed and when this wasn't already done; the response
* received when performing a request for the content referenced by this tag otherwise
* @throws IOException if an error occurs while downloading the content
*/
public WebResponse getWebResponse(final boolean downloadIfNeeded, WebRequest request) throws IOException {
if (downloadIfNeeded && cachedWebResponse_ == null) {
final WebClient webclient = getPage().getWebClient();
if (null == request) {
request = getWebRequest();
}
try {
cachedWebResponse_ = webclient.loadWebResponse(request);
final int statusCode = cachedWebResponse_.getStatusCode();
final boolean successful = statusCode >= HttpStatus.SC_OK
&& statusCode < HttpStatus.SC_MULTIPLE_CHOICES;
if (successful) {
executeEvent(Event.TYPE_LOAD);
}
else {
executeEvent(Event.TYPE_ERROR);
}
}
catch (final IOException e) {
executeEvent(Event.TYPE_ERROR);
throw e;
}
}
return cachedWebResponse_;
}
@Test
public void testGetNoProxyProjectMetadataDefaultLayout()
throws Exception
{
String commonsLangMetadata = "commons-lang/commons-lang/maven-metadata.xml";
String expectedMetadataContents = "dummy-project-metadata";
Path metadataFile = repoRootInternal.resolve(commonsLangMetadata);
Files.createDirectories(metadataFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile( metadataFile, Charset.defaultCharset(), expectedMetadataContents );
//WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/internal/" + commonsLangMetadata );
WebResponse response = getWebResponse( "/repository/internal/" + commonsLangMetadata );
assertResponseOK( response );
assertEquals( "Expected file contents", expectedMetadataContents, response.getContentAsString() );
}
@Test
public void testGetNoProxyDistributionLegacyLayoutManagedLegacy()
throws Exception
{
String expectedContents = "the-contents-of-the-dual-extension";
String dualExtensionPath = "org.project/distributions/example-presentation-3.2.zip";
Path checksumFile = repoRootLegacy.resolve(dualExtensionPath);
Files.createDirectories(checksumFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile(checksumFile, Charset.defaultCharset(), expectedContents);
WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/legacy/" + dualExtensionPath );
WebResponse response = getServletUnitClient().getResponse( request );
assertResponseNotFound( response );
}
@Test
public void testGetNoProxyProjectMetadataDefaultLayoutManagedLegacy()
throws Exception
{
// TODO: find out what it is meant to be from maven-artifact
String commonsLangMetadata = "commons-lang/commons-lang/maven-metadata.xml";
String expectedMetadataContents = "dummy-project-metadata";
Path metadataFile = repoRootLegacy.resolve(commonsLangMetadata);
Files.createDirectories(metadataFile.getParent());
org.apache.archiva.common.utils.FileUtils.writeStringToFile(metadataFile, Charset.defaultCharset(), expectedMetadataContents);
WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/legacy/" + commonsLangMetadata );
WebResponse response = getServletUnitClient().getResponse( request );
assertResponseNotFound( response );
}
@Test
public void testBrowse()
throws Exception
{
WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/internal/" );
WebResponse response = getServletUnitClient().getResponse( request );
assertEquals( "Response", HttpServletResponse.SC_OK, response.getStatusCode() );
// dumpResponse( response );
List<String> expectedLinks = Arrays.asList( ".indexer/", "commons-lang/", "net/", "org/" );
Document document = Jsoup.parse( response.getContentAsString() );
Elements elements = document.getElementsByTag( "a" );
assertLinks( expectedLinks, elements );
}
/**
* Performs the download and calls the callback method.
*/
@Override
public void run() {
final Scriptable scope = callback_.getParentScope();
final WebRequest request = new WebRequest(url_);
try {
final WebResponse webResponse = client_.loadWebResponse(request);
final String content = webResponse.getContentAsString();
if (LOG.isDebugEnabled()) {
LOG.debug("Downloaded content: " + StringUtils.abbreviate(content, 512));
}
final Object[] args = new Object[] {content};
final ContextAction action = new ContextAction() {
@Override
public Object run(final Context cx) {
callback_.call(cx, scope, scope, args);
return null;
}
};
final ContextFactory cf = ((JavaScriptEngine) client_.getJavaScriptEngine()).getContextFactory();
cf.call(action);
}
catch (final IOException e) {
LOG.error("Behavior #default#download: Cannot download " + url_, e);
}
}
/**
* Parses and then inserts the specified HTML content into the HTML content currently being parsed.
* @param html the HTML content to push
*/
@Override
public void pushInputString(final String html) {
page_.registerParsingStart();
page_.registerInlineSnippetParsingStart();
try {
final WebResponse webResponse = page_.getWebResponse();
final Charset charset = webResponse.getContentCharset();
final String url = webResponse.getWebRequest().getUrl().toString();
final XMLInputSource in = new XMLInputSource(null, url, null, new StringReader(html), charset.name());
((HTMLConfiguration) fConfiguration).evaluateInputSource(in);
}
finally {
page_.registerParsingEnd();
page_.registerInlineSnippetParsingEnd();
}
}
@Test
public void testControllerHappyPath() throws IOException {
Page page = webClient.getPage(baseURL.toString() + "mvc/mappers/success");
WebResponse webResponse = page.getWebResponse();
assertThat(webResponse.getStatusCode(), equalTo(200));
assertThat(webResponse.getContentType(), startsWith("text/html"));
assertThat(webResponse.getContentAsString(),
containsString("<h1>Controller was executed without errors!</h1>"));
}
@Override
public WebResponse getResponse(WebRequest request) throws IOException {
for (DelegateWebConnection connection : this.connections) {
if (connection.getMatcher().matches(request)) {
return connection.getDelegate().getResponse(request);
}
}
return this.defaultConnection.getResponse(request);
}
@Test
public void otherProduces1() throws Exception {
final WebResponse wr = webClient.loadWebResponse(
new WebRequest(new URL(webUrl + "resources/other_produces1"), ACCEPT_HEADER));
assertEquals(Response.Status.OK.getStatusCode(), wr.getStatusCode());
assertEquals(MediaType.APPLICATION_XHTML_XML, wr.getContentType());
}
@Test
public void language2() throws Exception {
final WebRequest wrq = new WebRequest(new URL(webUrl + "resources/language2"), ACCEPT_HEADER);
wrq.setAdditionalHeader("Accept-Language", ACCEPT_LANGUAGE);
final WebResponse wr = webClient.loadWebResponse(wrq);
assertEquals(Response.Status.OK.getStatusCode(), wr.getStatusCode());
assertEquals(MediaType.APPLICATION_XHTML_XML, wr.getContentType());
assertEquals("es", wr.getResponseHeaderValue("Content-Language"));
}
@Before
public void setup() throws Exception {
request = new WebRequest(new URL("http://localhost/"));
WebResponseData data = new WebResponseData("".getBytes("UTF-8"), 200, "", Collections.emptyList());
expectedResponse = new WebResponse(data, request, 100L);
webConnection = new DelegatingWebConnection(defaultConnection,
new DelegateWebConnection(matcher1, connection1), new DelegateWebConnection(matcher2, connection2));
}
@Test
public void getResponseDefault() throws Exception {
given(defaultConnection.getResponse(request)).willReturn(expectedResponse);
WebResponse response = webConnection.getResponse(request);
assertThat(response, sameInstance(expectedResponse));
verify(matcher1).matches(request);
verify(matcher2).matches(request);
verifyNoMoreInteractions(connection1, connection2);
verify(defaultConnection).getResponse(request);
}
/**
* Constructs a WebResponse object wrapping provided WebResponse.
* @param webResponse the webResponse that does the real work
* @throws IllegalArgumentException if the webResponse is {@code null}
*/
public WebResponseWrapper(final WebResponse webResponse) throws IllegalArgumentException {
super(null, null, 0);
if (webResponse == null) {
throw new IllegalArgumentException("Wrapped WebResponse can't be null");
}
wrappedWebResponse_ = webResponse;
}
@Test
public void getResponseSecondMatches() throws Exception {
given(matcher2.matches(request)).willReturn(true);
given(connection2.getResponse(request)).willReturn(expectedResponse);
WebResponse response = webConnection.getResponse(request);
assertThat(response, sameInstance(expectedResponse));
verify(matcher1).matches(request);
verify(matcher2).matches(request);
verifyNoMoreInteractions(connection1, defaultConnection);
verify(connection2).getResponse(request);
}
@Test
public void buildContentCharset() throws Exception {
this.response.addHeader("Content-Type", "text/html; charset=UTF-8");
WebResponse webResponse = this.responseBuilder.build();
assertThat(webResponse.getContentCharset(), equalTo("UTF-8"));
}
@Test
public void buildStatus() throws Exception {
WebResponse webResponse = this.responseBuilder.build();
assertThat(webResponse.getStatusCode(), equalTo(200));
assertThat(webResponse.getStatusMessage(), equalTo("OK"));
}
/**
* MRM-747
* test whether trying to overwrite existing relase-artifact is blocked by returning HTTP-code 409
*
* @throws Exception
*/
@Test
public void testReleaseArtifactsRedeploymentValidPath()
throws Exception
{
setupCleanRepo( repoRootInternal );
String putUrl = "http://machine.com/repository/internal" + ARTIFACT_DEFAULT_LAYOUT;
String metadataUrl = "http://machine.com/repository/internal/path/to/artifact/maven-metadata.xml";
String checksumUrl = "http://machine.com/repository/internal" + ARTIFACT_DEFAULT_LAYOUT + ".sha1";
InputStream is = getClass().getResourceAsStream( "/artifact.jar" );
// verify that the file exists in resources-dir
assertNotNull( "artifact.jar inputstream", is );
// send request #1 and verify it's successful
WebRequest request = new PutMethodWebRequest( putUrl, is, "application/octet-stream" );
WebResponse response = getServletUnitClient().getResponse( request );
assertResponseCreated( response );
is = getClass().getResourceAsStream( "/artifact.jar.sha1" );
request = new PutMethodWebRequest( checksumUrl, is, "application/octet-stream" );
response = getServletUnitClient().getResponse( request );
assertResponseCreated( response );
is = getClass().getResourceAsStream( "/maven-metadata.xml" );
request = new PutMethodWebRequest( metadataUrl, is, "application/octet-stream" );
response = getServletUnitClient().getResponse( request );
assertResponseCreated( response );
// send request #2 and verify it's blocked
is = getClass().getResourceAsStream( "/artifact.jar" );
request = new PutMethodWebRequest( putUrl, is, "application/octet-stream" );
response = getServletUnitClient().getResponse( request );
assertResponseConflictError( response );
}
@Override
public Page createPage(WebResponse webResponse, WebWindow webWindow) throws IOException {
String contentType = webResponse.getContentType().toLowerCase(Locale.ENGLISH);
if (contentType.equals("application/x-java-jnlp-file")) {
return createXmlPage(webResponse, webWindow);
}
// Need to sidestep HtmlUnit default behaviour here. It defaults the response type to
// being text/plain (and so creates a TextPage) if the content type in the response is
// blank + is an empty response.
if (contentType.isEmpty()) {
return createHtmlPage(webResponse, webWindow);
}
return super.createPage(webResponse, webWindow);
}