Java PortFactory类代码示例

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@BeforeClass
public static void startJetty() throws Exception {
    port = PortFactory.findFreePort();
    server = new Server();
    SslSocketConnector sslSocketConnector = new SslSocketConnector();
    sslSocketConnector.setKeystore("src/test/resources/keystore");
    sslSocketConnector.setKeyPassword("password");
    sslSocketConnector.setPort(port);
    server.setConnectors(new Connector[]{sslSocketConnector});
    server.addHandler(new AbstractHandler() {
        public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException {
            response.setStatus(Response.Status.OK.getStatusCode());
            Request base_request = request instanceof Request ? (Request) request : HttpConnection.getCurrentConnection().getRequest();
            base_request.setHandled(true);
        }
    });
    server.start();
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldVerifyReceivedRequests() throws Exception {
    // given
    Future<HttpResponse> responseSettableFuture =
        httpClient.sendRequest(
            request()
                .withPath("/some_path")
                .withHeader(HOST.toString(), "localhost:" + PortFactory.findFreePort()),
            new InetSocketAddress(clientAndServer.getLocalPort())
        );

    // then
    assertThat(responseSettableFuture.get(10, TimeUnit.SECONDS).getStatusCode(), is(404));

    // then
    clientAndServer.verify(request()
        .withPath("/some_path"));
    clientAndServer.verify(request()
        .withPath("/some_path"), VerificationTimes.exactly(1));
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Before
public void setupFixture() {
    httpPort = PortFactory.findFreePort();

    mockServerRuleDynamicPorts = new MockServerRule(this);
    mockServerRuleSinglePort = new MockServerRule(this, false, httpPort);
    mockServerRuleMultiplePorts = new MockServerRule(this, false, httpPort, httpPort + 1);
    mockServerRulePerSuite = new MockServerRule(this, true, httpPort);
    mockServerRulePerSuiteDuplicate = new MockServerRule(this, true, httpPort);

    initMocks(this);

    when(mockClientAndServer.getLocalPort()).thenReturn(httpPort);
    when(mockClientAndServer.getLocalPorts()).thenReturn(Arrays.asList(httpPort + 1, httpPort + 2));
    when(clientAndServerFactory.newClientAndServer()).thenReturn(mockClientAndServer);
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldStartMockServer() {
    // given
    final int freePort = PortFactory.findFreePort();
    MockServerClient mockServerClient = new MockServerClient("127.0.0.1", freePort);
    Level originalLogLevel = ConfigurationProperties.logLevel();

    try {
        // when
        Main.main(
            "-serverPort", String.valueOf(freePort),
            "-logLevel", "DEBUG"
        );

        // then
        assertThat(mockServerClient.isRunning(), is(true));
        assertThat(ConfigurationProperties.logLevel().toString(), is("DEBUG"));
    } finally {
        ConfigurationProperties.logLevel(originalLogLevel.toString());
        mockServerClient.stop();
    }
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldPrintOutUsageForInvalidRemotePort() throws UnsupportedEncodingException {
    // given
    final int freePort = PortFactory.findFreePort();
    PrintStream originalPrintStream = Main.systemOut;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Main.systemOut = new PrintStream(baos, true, StandardCharsets.UTF_8.name());

        // when
        Main.main("-serverPort", String.valueOf(freePort), "-proxyRemotePort", "A");

        // then
        String actual = new String(baos.toByteArray(), StandardCharsets.UTF_8);
        String expected = NEW_LINE +
            "   =======================================================================" + NEW_LINE +
            "   proxyRemotePort value \"A\" is invalid, please specify a port i.e. \"1080\"" + NEW_LINE +
            "   =======================================================================" + NEW_LINE +
            NEW_LINE +
            Main.USAGE;
        assertThat(actual, is(expected));
    } finally {
        Main.systemOut = originalPrintStream;
    }
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldPrintOutUsageForInvalidRemoteHost() throws UnsupportedEncodingException {
    // given
    final int freePort = PortFactory.findFreePort();
    PrintStream originalPrintStream = Main.systemOut;
    try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        Main.systemOut = new PrintStream(byteArrayOutputStream, true, StandardCharsets.UTF_8.name());

        // when
        Main.main("-serverPort", String.valueOf(freePort), "-proxyRemoteHost", "%^&*(");

        // then
        String actual = new String(byteArrayOutputStream.toByteArray(), StandardCharsets.UTF_8);
        String expected = NEW_LINE +
            "   ====================================================================================================" + NEW_LINE +
            "   proxyRemoteHost value \"%^&*(\" is invalid, please specify a host name i.e. \"localhost\" or \"127.0.0.1\"" + NEW_LINE +
            "   ====================================================================================================" + NEW_LINE +
            NEW_LINE +
            Main.USAGE;
        assertThat(actual, is(expected));
    } finally {
        Main.systemOut = originalPrintStream;
    }
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldPrintOutUsageForInvalidLogLevel() throws UnsupportedEncodingException {
    // given
    final int freePort = PortFactory.findFreePort();
    PrintStream originalPrintStream = Main.systemOut;
    try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        Main.systemOut = new PrintStream(byteArrayOutputStream, true, StandardCharsets.UTF_8.name());

        // when
        Main.main("-serverPort", String.valueOf(freePort), "-logLevel", "FOO");

        // then
        String actual = new String(byteArrayOutputStream.toByteArray(), StandardCharsets.UTF_8);
        String expected = NEW_LINE +
            "   =======================================================================================================" + NEW_LINE +
            "   logLevel value \"FOO\" is invalid, please specify one of \"TRACE\", \"DEBUG\", \"INFO\", \"WARN\", \"ERROR\", \"OFF\"" + NEW_LINE +
            "   =======================================================================================================" + NEW_LINE +
            NEW_LINE +
            Main.USAGE;
        assertThat(actual, is(expected));
    } finally {
        Main.systemOut = originalPrintStream;
    }
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@BeforeClass
public static void initialize() throws Exception {
  port = PortFactory.findFreePort();
  mockServer = startClientAndServer(port);
  rsContext = new ResourceSyncContext();
  httpclient = HttpClients.createDefault();
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@BeforeClass
public static void startServer() throws Exception {
    int port = PortFactory.findFreePort();
    System.out.println("port is " + port);
    mockServer = ClientAndServer.startClientAndServer(port);
    baseUrl = "http://localhost:" + port;
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@BeforeClass
public static void startProxy() throws Exception {

  int port = PortFactory.findFreePort();
  clientAndProxy = startClientAndProxy(port);
  proxy = new HttpHost("localhost", port);
  // load truststore with MockServer CA
  sslContext = SSLContexts.custom().loadTrustMaterial(new File("src/test/resources/truststore.jks"), "changeit".toCharArray()).build();
  httpClientBuilder = HttpClients.custom().setSSLContext(sslContext);
  httpclient = httpClientBuilder.build();

  serverPort = PortFactory.findFreePort();
  clientAndServer = ClientAndServer.startClientAndServer(serverPort);
  clientAndServer.when(new HttpRequest().withMethod("GET")).respond(HttpResponse.response("OK"));
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    creationUrl = new URL("http://master.tus.io");
    int port = PortFactory.findFreePort();
    mockServerURL = new URL("http://localhost:" + port + "/files");
    mockServer = startClientAndServer(port);
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@BeforeClass
public static void startProxy() throws Exception {
	if (isUsingMockServer()) {
		previousFactory = HttpsURLConnection.getDefaultSSLSocketFactory();
		HttpsURLConnection.setDefaultSSLSocketFactory(SSLFactory.getInstance().sslContext().getSocketFactory());
		proxy = ClientAndProxy.startClientAndProxy(PortFactory.findFreePort());
		mockServer = ClientAndServer.startClientAndServer(MOCKSERVER_PORT);
	}
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@BeforeClass
public static void startServer() {
    mockServerClient = startClientAndServer(0, PortFactory.findFreePort(), 0, PortFactory.findFreePort());
    List<Integer> boundPorts = ((ClientAndServer) mockServerClient).getLocalPorts();
    severHttpPort = boundPorts.toArray(new Integer[boundPorts.size()]);

    echoServer = new EchoServer(false);
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldNotForwardRequestWithInvalidHostHead() throws Exception {
    // when
    Future<HttpResponse> responseSettableFuture =
        httpClient.sendRequest(
            request()
                .withPath("/some_path")
                .withHeader(HOST.toString(), "localhost:" + PortFactory.findFreePort()),
            new InetSocketAddress(clientAndServer.getLocalPort())
        );

    // then
    assertThat(responseSettableFuture.get(10, TimeUnit.SECONDS).getStatusCode(), is(404));
}
 

import org.mockserver.socket.PortFactory; //导入依赖的package包/类
@Test
public void shouldThrowSocketCommunicationExceptionForConnectException() throws Exception {
    // then
    int freePort = PortFactory.findFreePort();
    exception.expect(ExecutionException.class);
    exception.expectMessage(anyOf(
        containsString("Connection refused: /127.0.0.1:" + freePort),
        containsString("Channel closed before valid response")
    ));

    // when
    new NettyHttpClient().sendRequest(request().withHeader(HOST.toString(), "127.0.0.1:" + freePort))
        .get(10, TimeUnit.SECONDS);
}