Clean-up and update Confidential Ledger tests for proxy migration (Az…

…ure#36343)

* Update test-resources.json to reflect existing .NET scripts.

* Add common environment variable names.

* Fix script path for test-resources-pre.ps1

* use envs for names.

* Fix naming from Ledge -> Ledger

* Add pom.xml imports for reflection during tests.

* Change to eastus like .NET.

* Fix test for LedgerIdentity.

* Adding shared object mapper.

* Fix warning in sample.

* Fix tests for ledger entries.

* Remove assertion of ledger cert.

* Update recordings for two tests.

sdk/confidentialledger/azure-security-confidentialledger/pom.xml

@@ -32,7 +32,10 @@
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <javaModulesSurefireArgLine>
+      --add-exports com.azure.core/com.azure.core.implementation=ALL-UNNAMED
       --add-exports com.azure.core/com.azure.core.implementation.jackson=ALL-UNNAMED
+      --add-exports com.azure.core/com.azure.core.implementation.util=ALL-UNNAMED
+
       --add-exports com.azure.http.netty/com.azure.core.http.netty=com.azure.security.confidentialledger
 
       --add-reads com.azure.security.confidentialledger=com.azure.http.netty

sdk/confidentialledger/azure-security-confidentialledger/src/samples/java/com/azure/security/confidentialledger/PostLedgerEntrySample.java

@@ -5,6 +5,7 @@
 
 import java.io.IOException;
 
+import com.azure.core.http.HttpHeaderName;
 import org.junit.jupiter.api.Assertions;
 
 import com.azure.core.http.rest.RequestOptions;
@@ -34,7 +35,7 @@ public static void main(String[] args) {
         JsonNode responseBodyJson = null;
 
         try {
-            
+
             responseBodyJson = objectMapper.readTree(parsedResponse.toBytes());
         } catch (IOException e) {
             e.printStackTrace();
@@ -44,12 +45,14 @@ public static void main(String[] args) {
         String collectionId = responseBodyJson.get("collectionId").asText();
 
         // you can use the transaction id to get the transaction status
-        String transactionId = response.getHeaders().get("x-ms-ccf-transaction-id").getValue();
+        String transactionId = response.getHeaders()
+            .get(HttpHeaderName.fromString("x-ms-ccf-transaction-id"))
+            .getValue();
 
         requestOptions = new RequestOptions();
         // the transactionId can be retrieved after posting to a ledger (see PostLedgerEntry.java)
         Response<BinaryData> transactionResponse = confidentialLedgerClient.getTransactionStatusWithResponse(transactionId, requestOptions);
-    
+
         JsonNode transactionResponseBodyJson = null;
 
         try {

sdk/confidentialledger/azure-security-confidentialledger/src/test/java/com/azure/security/confidentialledger/ConfidentialLedgerClientTestBase.java

@@ -6,43 +6,51 @@
 
 import com.azure.core.credential.AccessToken;
 import com.azure.core.http.HttpClient;
+import com.azure.core.http.HttpHeaderName;
 import com.azure.core.http.netty.NettyAsyncHttpClientBuilder;
 import com.azure.core.http.policy.HttpLogDetailLevel;
 import com.azure.core.http.policy.HttpLogOptions;
+import com.azure.core.http.rest.RequestOptions;
 import com.azure.core.http.rest.Response;
 import com.azure.core.test.TestBase;
 import com.azure.core.test.TestMode;
 import com.azure.core.util.BinaryData;
-import com.azure.core.util.Configuration;
 import com.azure.identity.DefaultAzureCredentialBuilder;
 import com.azure.security.confidentialledger.certificate.ConfidentialLedgerCertificateClient;
 import com.azure.security.confidentialledger.certificate.ConfidentialLedgerCertificateClientBuilder;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslContextBuilder;
+import org.junit.jupiter.api.Assertions;
 import reactor.core.publisher.Mono;
 
+import javax.net.ssl.SSLException;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.time.OffsetDateTime;
 
-import javax.net.ssl.SSLException;
-
-import org.junit.jupiter.api.Assertions;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 class ConfidentialLedgerClientTestBase extends TestBase {
+    protected static final String TRANSACTION_ID = "transactionId";
+    protected static final String COLLECTION_ID = "collectionId";
+    protected static final BinaryData BINARY_DATA =
+        BinaryData.fromString("{\"contents\":\"New ledger entry contents.\"}");
+
+    protected static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
     protected ConfidentialLedgerClient confidentialLedgerClient;
     protected ConfidentialLedgerClientBuilder confidentialLedgerClientBuilder;
     protected ConfidentialLedgerCertificateClient confidentialLedgerCertificateClient;
 
     @Override
     protected void beforeTest() {
         ConfidentialLedgerCertificateClientBuilder confidentialLedgerCertificateClientBuilder = new ConfidentialLedgerCertificateClientBuilder()
-            .certificateEndpoint("https://identity.confidential-ledger.core.azure.com")
-            .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BASIC));
+            .certificateEndpoint(ConfidentialLedgerEnvironment.getConfidentialLedgerIdentityUrl())
+            .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY));
 
         if (getTestMode() == TestMode.PLAYBACK) {
             confidentialLedgerCertificateClientBuilder
@@ -58,10 +66,8 @@ protected void beforeTest() {
 
         confidentialLedgerCertificateClient = confidentialLedgerCertificateClientBuilder.buildClient();
 
-        String ledgerName = Configuration.getGlobalConfiguration().get("LEDGER_NAME", "java-sdk-live-tests-ledger");
-
         Response<BinaryData> ledgerIdentityWithResponse = confidentialLedgerCertificateClient
-            .getLedgerIdentityWithResponse(ledgerName, null);
+            .getLedgerIdentityWithResponse(ConfidentialLedgerEnvironment.getConfidentialLedgerName(), null);
         BinaryData identityResponse = ledgerIdentityWithResponse.getValue();
         ObjectMapper mapper = new ObjectMapper();
         JsonNode jsonNode = null;
@@ -91,7 +97,7 @@ protected void beforeTest() {
         HttpClient httpClient = new NettyAsyncHttpClientBuilder(reactorClient).wiretap(true).build();
 
         confidentialLedgerClientBuilder = new ConfidentialLedgerClientBuilder()
-            .ledgerEndpoint(Configuration.getGlobalConfiguration().get("LEDGER_URI", "https://java-sdk-live-tests-ledger.confidential-ledger.azure.com"))
+            .ledgerEndpoint(ConfidentialLedgerEnvironment.getConfidentialLedgerUrl())
             .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BASIC));
 
         if (getTestMode() == TestMode.PLAYBACK) {
@@ -111,4 +117,35 @@ protected void beforeTest() {
         confidentialLedgerClient = confidentialLedgerClientBuilder.buildClient();
     }
 
+    /**
+     * Posts and asserts that an entry was added.  Useful for tests that require a ledger entry.
+     *
+     * @return The transaction id associated with the ledger entry.
+     */
+    protected String postLedgerEntry() throws IOException {
+        // Arrange
+        final RequestOptions options = new RequestOptions();
+        final String contents = BINARY_DATA.toString();
+
+        // Act
+        final Response<BinaryData> response =
+            confidentialLedgerClient.createLedgerEntryWithResponse(BINARY_DATA, options);
+
+        // Assert
+        assertEquals(200, response.getStatusCode());
+
+        JsonNode jsonNode = OBJECT_MAPPER.readTree(response.getValue().toBytes());
+        JsonNode collectionIdNode = jsonNode.get("collectionId");
+
+        assertNotNull(collectionIdNode);
+        assertEquals("subledger:0", collectionIdNode.asText());
+
+        String transactionId = response.getHeaders()
+            .get(HttpHeaderName.fromString("x-ms-ccf-transaction-id"))
+            .getValue();
+
+        assertNotNull(transactionId, "transaction id should exist on headers.");
+
+        return transactionId;
+    }
 }

sdk/confidentialledger/azure-security-confidentialledger/src/test/java/com/azure/security/confidentialledger/ConfidentialLedgerEnvironment.java

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.security.confidentialledger;
+
+import com.azure.core.util.Configuration;
+
+/**
+ * Set of environment variables shared in confidential ledger tests.
+ */
+public class ConfidentialLedgerEnvironment {
+
+    private static final Configuration GLOBAL_CONFIGURATION = Configuration.getGlobalConfiguration();
+
+    public static String getConfidentialLedgerName() {
+        return GLOBAL_CONFIGURATION.get("CONFIDENTIALLEDGER_NAME", "java-sdk-live-tests-ledger");
+    }
+
+    public static String getConfidentialLedgerUrl() {
+        return GLOBAL_CONFIGURATION.get("CONFIDENTIALLEDGER_URL",
+            "https://" + getConfidentialLedgerName() + ".confidential-ledger.azure.com");
+    }
+
+    public static String getConfidentialLedgerIdentityUrl() {
+        return GLOBAL_CONFIGURATION.get("CONFIDENTIALLEDGER_IDENTITY_URL", "https://identity.confidential-ledger.core.azure.com");
+    }
+
+    public static String getConfidentialLedgerAdminOid() {
+        return GLOBAL_CONFIGURATION.get("CONFIDENTIALLEDGER_CLIENT_OBJECTID", "d958292f-5b70-4b66-9502-562217cc7eaa");
+    }
+
+    public static String getClientPEM() {
+        return GLOBAL_CONFIGURATION.get("CONFIDENTIALLEDGER_CLIENT_PEM", "test-pem");
+    }
+
+    public static String getClientPEMPk() {
+        return GLOBAL_CONFIGURATION.get("CONFIDENTIALLEDGER_CLIENT_PEM_PK", "test-pek");
+    }
+}

sdk/confidentialledger/azure-security-confidentialledger/src/test/java/com/azure/security/confidentialledger/LedgerEntriesTest.java

@@ -10,74 +10,59 @@
 import com.azure.core.util.BinaryData;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.Isolated;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
+@Isolated("There is an assumption in post ledger entries that checks it is latest entry.")
 public final class LedgerEntriesTest extends ConfidentialLedgerClientTestBase {
     @Test
     public void testPostLedgerEntryTests() throws Exception {
-        BinaryData entry = BinaryData.fromString("{\"contents\":\"New ledger entry contents.\"}");
+        // Arrange
         RequestOptions requestOptions = new RequestOptions();
-        Response<BinaryData> response = confidentialLedgerClient.createLedgerEntryWithResponse(entry, requestOptions);
-
-        String transactionId = response.getHeaders().get("x-ms-ccf-transaction-id").getValue();
-
-        BinaryData parsedResponse = response.getValue();
-
-        ObjectMapper objectMapper = new ObjectMapper();
-        JsonNode responseBodyJson = null;
-
-        responseBodyJson = objectMapper.readTree(parsedResponse.toBytes());
-
-        Assertions.assertEquals(responseBodyJson.get("collectionId").asText(), "subledger:0");
+        String transactionId = postLedgerEntry();
 
         Response<BinaryData> transactionResponse = confidentialLedgerClient.getTransactionStatusWithResponse(transactionId, requestOptions);
 
-        JsonNode transactionResponseBodyJson = null;
+        JsonNode transactionResponseBodyJson = OBJECT_MAPPER.readTree(transactionResponse.getValue().toBytes());
 
-        try {
-            transactionResponseBodyJson = objectMapper.readTree(transactionResponse.getValue().toBytes());
-        } catch (IOException e) {
-            e.printStackTrace();
-            Assertions.assertTrue(false);
-        }
+        assertEquals(transactionResponseBodyJson.get(TRANSACTION_ID).asText(), transactionId);
 
-        Assertions.assertEquals(transactionResponseBodyJson.get("transactionId").asText(), transactionId);
-        Assertions.assertTrue(200 == transactionResponse.getStatusCode() || 406 == transactionResponse.getStatusCode());
+        int statusCode = transactionResponse.getStatusCode();
+        assertTrue(200 == statusCode || 406 == statusCode, "Expected 200, or 206. Actual: " + statusCode);
 
+        // Act
         Response<BinaryData> currentResponse = confidentialLedgerClient.getCurrentLedgerEntryWithResponse(requestOptions);
 
-        JsonNode currentResponseBodyJson = null;
+        // Assert
+        JsonNode currentResponseBodyJson = OBJECT_MAPPER.readTree(currentResponse.getValue().toBytes());
 
-        try {
-
-            currentResponseBodyJson = objectMapper.readTree(currentResponse.getValue().toBytes());
-        } catch (IOException e) {
-            e.printStackTrace();
-            Assertions.assertTrue(false);
-        }
-
-        Assertions.assertTrue(200 == currentResponse.getStatusCode() || 406 == currentResponse.getStatusCode());
+        assertTrue(200 == currentResponse.getStatusCode() || 406 == currentResponse.getStatusCode());
 
         if (200 == currentResponse.getStatusCode()) {
-            // we assume no one else is using this test ledger
-            Assertions.assertTrue(currentResponseBodyJson.get("transactionId").asDouble() <= Double.parseDouble(transactionId));
+            // we assume no one has created an entry since we created this entry.
+            assertTrue(currentResponseBodyJson.get(TRANSACTION_ID).asDouble() <= Double.parseDouble(transactionId));
         }
     }
 
     @Test
     public void testGetCollectionIdsTests() throws Exception {
+        postLedgerEntry();
+
         RequestOptions requestOptions = new RequestOptions();
         PagedIterable<BinaryData> pagedIterableResponse = confidentialLedgerClient.listCollections(requestOptions);
 
         List<String> collectionKeys = new ArrayList<>();
 
         pagedIterableResponse.streamByPage().forEach(resp -> {
-            Assertions.assertEquals(200, resp.getStatusCode());
+            assertEquals(200, resp.getStatusCode());
             resp.getValue().forEach(item -> {
                 ObjectMapper objectMapper = new ObjectMapper();
                 JsonNode responseBodyJson = null;
@@ -86,14 +71,15 @@ public void testGetCollectionIdsTests() throws Exception {
                     responseBodyJson = objectMapper.readTree(item.toBytes());
                 } catch (IOException e) {
                     e.printStackTrace();
-                    Assertions.assertTrue(false);
+                    assertTrue(false);
                 }
 
-                Assertions.assertNotNull(responseBodyJson.get("collectionId"));
-                collectionKeys.add(responseBodyJson.get("collectionId").asText());
+                Assertions.assertNotNull(responseBodyJson.get(COLLECTION_ID));
+                collectionKeys.add(responseBodyJson.get(COLLECTION_ID).asText());
             });
 
-            collectionKeys.stream().anyMatch((item) -> item.contains("subledger:0"));
+            boolean exists = collectionKeys.stream().anyMatch((item) -> item.contains("subledger:0"));
+            assertTrue(exists, "Did not find matching collection.");
         });
     }
 }

sdk/confidentialledger/azure-security-confidentialledger/src/test/java/com/azure/security/confidentialledger/UserTests.java

@@ -7,19 +7,17 @@
 import com.azure.core.http.rest.RequestOptions;
 import com.azure.core.http.rest.Response;
 import com.azure.core.util.BinaryData;
-import com.azure.core.util.Configuration;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-
-import java.io.IOException;
-
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.io.IOException;
+
 public final class UserTests extends ConfidentialLedgerClientTestBase {
     @Test
     public void testGetUserTests() throws Exception {
-        String userAad = Configuration.getGlobalConfiguration().get("USER_AAD", "d958292f-5b70-4b66-9502-562217cc7eaa");
+        String userAad = ConfidentialLedgerEnvironment.getConfidentialLedgerAdminOid();
         RequestOptions requestOptions = new RequestOptions();
 
         Response<BinaryData> response = confidentialLedgerClient.getUserWithResponse(userAad, requestOptions);

sdk/confidentialledger/azure-security-confidentialledger/src/test/java/com/azure/security/confidentialledger/certificate/generated/ConfidentialLedgerCertificateClientTestBase.java

@@ -10,25 +10,29 @@
 import com.azure.core.http.policy.HttpLogOptions;
 import com.azure.core.test.TestBase;
 import com.azure.core.test.TestMode;
-import com.azure.core.util.Configuration;
 import com.azure.identity.DefaultAzureCredentialBuilder;
+import com.azure.security.confidentialledger.ConfidentialLedgerEnvironment;
 import com.azure.security.confidentialledger.certificate.ConfidentialLedgerCertificateClient;
 import com.azure.security.confidentialledger.certificate.ConfidentialLedgerCertificateClientBuilder;
-import java.time.OffsetDateTime;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import reactor.core.publisher.Mono;
 
+import java.time.OffsetDateTime;
+
 class ConfidentialLedgerCertificateClientTestBase extends TestBase {
+    protected static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
     protected ConfidentialLedgerCertificateClient confidentialLedgerCertificateClient;
 
     @Override
     protected void beforeTest() {
         ConfidentialLedgerCertificateClientBuilder confidentialLedgerCertificateClientbuilder =
                 new ConfidentialLedgerCertificateClientBuilder()
                         .certificateEndpoint(
-                                Configuration.getGlobalConfiguration()
-                                        .get("CERTIFICATEENDPOINT", "certificateendpoint"))
+                            ConfidentialLedgerEnvironment.getConfidentialLedgerIdentityUrl())
                         .httpClient(HttpClient.createDefault())
                         .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BASIC));
+
         if (getTestMode() == TestMode.PLAYBACK) {
             confidentialLedgerCertificateClientbuilder
                     .httpClient(interceptorManager.getPlaybackClient())