Made the description a bit brief and removed extra details

Author: agrja-rastogi-okta

README.md

@@ -806,205 +806,15 @@ ApiClient client = Clients.builder()
 
 ## WireMock Integration Testing
 
-### Overview
-
-WireMock enables testing with the Okta Java SDK by providing a mock HTTP server that simulates Okta's API endpoints over HTTPS. This eliminates the need to hit actual Okta servers during development and testing, removing rate limit concerns and enabling rapid iteration.
-
-### Problem
-
-The Okta SDK requires HTTPS connections, and when using WireMock with self-signed certificates, the SDK's HTTP client must be configured to trust the mock server's certificate. This section demonstrates the complete setup.
-
-### Solution Architecture
-
-The solution consists of three components:
-
-1. **Self-Signed Certificate Generation**: Automatically generates a JKS keystore with a self-signed certificate
-2. **WireMock HTTPS Configuration**: Configures WireMock server to use the certificate
-3. **Custom SSL Context**: Configures the Okta SDK's HTTP client to trust the certificate
-
-### Implementation
-
-#### Step 1: Automatic Certificate Generation
-
-The test setup automatically generates a self-signed certificate on first run:
-
-```java
-String keystorePath = Paths.get(KEYSTORE_PATH).toAbsolutePath().toString();
-java.io.File keystoreFile = new java.io.File(keystorePath);
-if (!keystoreFile.exists()) {
-    ProcessBuilder pb = new ProcessBuilder(
-        "keytool", "-genkey", "-alias", "wiremock", "-keyalg", "RSA",
-        "-keystore", keystorePath,
-        "-storepass", "password", "-keypass", "password",
-        "-dname", "CN=localhost", "-validity", "365", "-noprompt"
-    );
-    int exitCode = pb.start().waitFor();
-    if (exitCode != 0) {
-        throw new RuntimeException("Failed to generate WireMock keystore");
-    }
-}
-```
-
-The certificate is generated once and reused for subsequent test runs. The `.gitignore` file excludes the keystore from version control to maintain security best practices.
-
-#### Step 2: Configure WireMock Server
-
-Start WireMock on HTTPS port 8443 using the generated certificate:
-
-```java
-wireMockServer = new WireMockServer(
-    WireMockConfiguration.wireMockConfig()
-        .httpsPort(8443)
-        .keystorePath(keystorePath)
-        .keystorePassword("password")
-);
-wireMockServer.start();
-```
-
-#### Step 3: Create Custom SSL Context
-
-Load the keystore and configure an SSL context that trusts the self-signed certificate:
-
-```java
-KeyStore trustStore = KeyStore.getInstance("JKS");
-try (FileInputStream fis = new FileInputStream(keystorePath)) {
-    trustStore.load(fis, "password".toCharArray());
-}
-
-TrustManagerFactory tmf = TrustManagerFactory.getInstance(
-    TrustManagerFactory.getDefaultAlgorithm());
-tmf.init(trustStore);
-
-SSLContext sslContext = SSLContext.getInstance("TLS");
-sslContext.init(null, tmf.getTrustManagers(), new java.security.SecureRandom());
-```
-
-#### Step 4: Configure HTTP Client with Custom SSL Context
-
-Create the HTTP client with dynamic port allocation for thread safety:
-
-```java
-// Find an available port for thread-safe parallel execution
-ServerSocket socket = new ServerSocket(0);
-int wiremockPort = socket.getLocalPort();
-socket.close();
-
-org.apache.hc.client5.http.impl.classic.CloseableHttpClient httpClient = 
-    HttpClients.custom()
-        .setConnectionManager(
-            PoolingHttpClientConnectionManagerBuilder.create()
-                .setSSLSocketFactory(
-                    new org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory(sslContext)
-                )
-                .build()
-        )
-        .build();
-```
-
-#### Step 5: Create Okta API Client
-
-Instantiate the API client with the custom HTTP client:
-
-```java
-client = new ApiClient(httpClient, new com.okta.sdk.impl.cache.DisabledCacheManager());
-client.setBasePath("https://localhost:" + wiremockPort);
-
-userApi = new UserApi(client);
-```
-
-### Usage Example
-
-Define API endpoint mocks using WireMock's stubFor pattern:
-
-```java
-@Test
-public void testGetUser() throws ApiException {
-    String userId = "00ub0oNGTSWTBKOLGLHN";
-    
-    stubFor(get(urlEqualTo("/api/v1/users/" + userId))
-        .willReturn(aResponse()
-            .withStatus(200)
-            .withHeader("Content-Type", "application/json")
-            .withBody("{" +
-                "\"id\":\"" + userId + "\"," +
-                "\"status\":\"ACTIVE\"," +
-                "\"profile\":{" +
-                    "\"email\":\"user@example.com\"" +
-                "}" +
-            "}")
-        ));
-
-    User user = userApi.getUser(userId, null, null);
-    
-    assertNotNull(user);
-    assertEquals(userId, user.getId());
-    assertEquals("ACTIVE", user.getStatus().toString());
-}
-```
-
-### Thread Safety
-
-The implementation uses dynamic port allocation to ensure thread-safe parallel test execution:
-
-```java
-ServerSocket socket = new ServerSocket(0);  // OS assigns available port
-int wiremockPort = socket.getLocalPort();
-socket.close();
-```
-
-This approach allows multiple test instances to run simultaneously, each with its own isolated WireMock server instance on a unique port.
-
-### Reference Implementation
-
-A complete working example is provided in `integration-tests/src/test/java/com/okta/sdk/tests/WireMockOktaClientTest.java` with test cases for:
-
-- Single user retrieval (testGetUser)
-- User list operations (testListUsers)
-- HTTPS configuration verification (testWireMockHttps)
+WireMock can be configured to serve HTTPS with a self-signed certificate and custom KeyStore. The SDK's HTTP client can be configured with a custom SSLContext and TrustManager to accept the certificate. This implementation demonstrates both: automatic self-signed certificate generation, WireMock HTTPS configuration, and SDK HTTP client setup with a custom TrustManager. It also uses dynamic port allocation for thread-safe parallel test execution.
 
 ### Running the Tests
 
-Execute the integration tests with:
-
 ```bash
 mvn test -Dtest=WireMockOktaClientTest -pl integration-tests
 ```
 
-Expected output:
-
-```
-Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
-```
-
-### Prerequisites
-
-- Java Development Kit (JDK) 8 or later
-- Apache Maven 3.6 or later
-- keytool (included with JDK)
-
-### Troubleshooting
-
-**Port Already in Use**
-
-If port 8443 is in use, the dynamic port allocation in the current implementation automatically selects an available port. Ensure you pass the dynamically assigned port to the client configuration.
-
-**Certificate Trust Issues**
-
-Verify that the keystore file is generated and accessible:
-
-```bash
-ls -la wiremock-keystore.jks
-```
-
-If the file is missing or corrupted, delete it and run tests again to regenerate.
-
-**keytool Not Found**
-
-keytool is included with the JDK. Ensure JAVA_HOME is properly configured:
-
-```bash
-echo $JAVA_HOME
-```
+See the complete implementation in `integration-tests/src/test/java/com/okta/sdk/tests/WireMockOktaClientTest.java`.
 
 ## Building the SDK