refactor NodeUpdateTransactionIntegrationTest to fix Codacy warning

Signed-off-by: emiliyank <e.kadiyski@gmail.com>

Author: emiliyank

sdk/src/main/java/com/hedera/hashgraph/sdk/Client.java

@@ -1416,19 +1416,16 @@ public synchronized Client updateNetworkFromAddressBook() {
             var fileId = FileId.getAddressBookFileIdFor(this.shard, this.realm);
 
             logger.debug("Fetching address book from file {}", fileId);
-            System.out.println("Fetching address book from file " + fileId);
 
             // Execute synchronously - no async complexity
             var addressBook = new AddressBookQuery().setFileId(fileId).execute(this); // ← Synchronous!
 
             logger.debug("Received address book with {} nodes", addressBook.nodeAddresses.size());
-            System.out.println("address book size: " + addressBook.nodeAddresses.size());
 
             // Update the network
             this.setNetworkFromAddressBook(addressBook);
 
             logger.info("Address book update completed successfully");
-            System.out.println("Address book update completed successfully");
 
         } catch (TimeoutException e) {
             logger.warn("Failed to fetch address book: {}", e.getMessage());

sdk/src/main/java/com/hedera/hashgraph/sdk/Executable.java

@@ -792,9 +792,11 @@ private void executeAsyncInternal(
                                             if (status == com.hedera.hashgraph.sdk.Status.INVALID_NODE_ACCOUNT) {
                                                 if (logger.isEnabledForLevel(LogLevel.TRACE)) {
                                                     logger.trace(
-                                                        "Received INVALID_NODE_ACCOUNT; updating address book and marking node {} as unhealthy, attempt #{}",
-                                                        grpcRequest.getNode().getAccountId(),
-                                                        attempt);
+                                                            "Received INVALID_NODE_ACCOUNT; updating address book and marking node {} as unhealthy, attempt #{}",
+                                                            grpcRequest
+                                                                    .getNode()
+                                                                    .getAccountId(),
+                                                            attempt);
                                                 }
                                                 // Schedule async address book update
                                                 client.updateNetworkFromAddressBook();

sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NodeUpdateTransactionIntegrationTest.java

@@ -88,14 +88,7 @@ void shouldSucceedWhenUpdatingNodeAccountIdWithProperSignatures() throws Excepti
             // Given: A node with an existing account ID (0.0.3)
             // First, create a new account that will be used as the new node account ID
             var newAccountKey = PrivateKey.generateED25519();
-            var newAccountCreateTransaction = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(10))
-                    .setMaxTransactionFee(Hbar.from(1));
-
-            var newAccountResponse = newAccountCreateTransaction.execute(client);
-            var newAccountReceipt = newAccountResponse.getReceipt(client);
-            var newAccountId = newAccountReceipt.accountId;
+            var newAccountId = createAccount(client, newAccountKey.getPublicKey(), Hbar.from(10));
 
             // Create a node admin key
             var nodeAdminKey = PrivateKey.generateED25519();
@@ -174,17 +167,11 @@ void testNodeUpdateTransactionCanChangeNodeAccountUpdateAddressbookAndRetry() th
             client.setOperator(new AccountId(0, 0, 2), originalOperatorKey);
 
             // Create the account that will be the node account id
-            var resp = new AccountCreateTransaction()
-                    .setKey(originalOperatorKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(1))
-                    .execute(client);
-
-            var receipt = resp.setValidateStatus(true).getReceipt(client);
-            var newNodeAccountID = receipt.accountId;
+            var newNodeAccountID = createAccount(client, originalOperatorKey.getPublicKey(), Hbar.from(1));
             assertThat(newNodeAccountID).isNotNull();
 
             // Update node account id (0.0.3 -> newNodeAccountID)
-            resp = new NodeUpdateTransaction()
+            var resp = new NodeUpdateTransaction()
                     .setNodeId(0)
                     .setDescription("testUpdated")
                     .setAccountId(newNodeAccountID)
@@ -193,14 +180,12 @@ void testNodeUpdateTransactionCanChangeNodeAccountUpdateAddressbookAndRetry() th
             System.out.println("Transaction node: " + resp.nodeId);
             System.out.println("Receipt query nodes: " + resp.getReceiptQuery().getNodeAccountIds());
             System.out.println("Client network: " + client.getNetwork());
-            receipt = resp.setValidateStatus(true).getReceipt(client);
+            var receipt = resp.setValidateStatus(true).getReceipt(client);
             assertThat(receipt.status).isEqualTo(Status.SUCCESS);
 
             // Wait for mirror node to import data
             Thread.sleep(10000);
 
-            var newAccountKey = PrivateKey.generateED25519();
-
             // Submit to node 3 and node 4
             // Node 3 will fail with INVALID_NODE_ACCOUNT (because it now uses newNodeAccountID)
             // The SDK should automatically:
@@ -209,23 +194,10 @@ void testNodeUpdateTransactionCanChangeNodeAccountUpdateAddressbookAndRetry() th
             // 3. Update the address book asynchronously
             // 4. Mark node 3 as unhealthy
             // 5. Retry with node 4 which should succeed
-            resp = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setNodeAccountIds(List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)))
-                    .execute(client);
-
-            // If we reach here without exception, the SDK successfully handled the error and retried
-            assertThat(resp).isNotNull();
+            executeAccountCreate(client, List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)));
 
             // This transaction should succeed using the updated node account ID
-            resp = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setNodeAccountIds(List.of(newNodeAccountID))
-                    .execute(client);
-
-            assertThat(resp).isNotNull();
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+            executeAccountCreate(client, List.of(newNodeAccountID));
 
             // Revert the node account id (newNodeAccountID -> 0.0.3)
             resp = new NodeUpdateTransaction()
@@ -259,12 +231,7 @@ void testNodeUpdateTransactionFailsWithInvalidSignatureWhenMissingNodeAdminSigna
 
             // Given: Create a new operator account without node admin privileges
             var newOperatorKey = PrivateKey.generateED25519();
-            var newAccountResponse = new AccountCreateTransaction()
-                    .setKey(newOperatorKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(2))
-                    .execute(client);
-
-            var newOperatorAccountId = newAccountResponse.getReceipt(client).accountId;
+            var newOperatorAccountId = createAccount(client, newOperatorKey.getPublicKey(), Hbar.from(2));
 
             // Switch to the new operator (who doesn't have node admin privileges)
             client.setOperator(newOperatorAccountId, newOperatorKey);
@@ -310,12 +277,7 @@ void testNodeUpdateTransactionFailsWithInvalidSignatureWhenMissingAccountIdSigna
 
             // Given: Create a new account that will be used as the new node account ID
             var newAccountKey = PrivateKey.generateED25519();
-            var newAccountResponse = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(2))
-                    .execute(client);
-
-            var newAccountId = newAccountResponse.getReceipt(client).accountId;
+            var newAccountId = createAccount(client, newAccountKey.getPublicKey(), Hbar.from(2));
 
             // When: A NodeUpdateTransaction is submitted with node admin signature
             // but WITHOUT the new account ID's signature
@@ -404,12 +366,7 @@ void testNodeUpdateTransactionFailsWithAccountDeletedForDeletedAccount() throws
 
             // Given: Create a new account that will be deleted
             var newAccountKey = PrivateKey.generateED25519();
-            var newAccountResponse = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(2))
-                    .execute(client);
-
-            var newAccountId = newAccountResponse.getReceipt(client).accountId;
+            var newAccountId = createAccount(client, newAccountKey.getPublicKey(), Hbar.from(2));
 
             // Delete the account (transfer balance to operator account)
             var deleteResponse = new AccountDeleteTransaction()
@@ -463,23 +420,17 @@ void testSubsequentTransactionWithNewNodeAccountIdSucceeds() throws Exception {
             client.setOperator(new AccountId(0, 0, 2), originalOperatorKey);
 
             // Given: Create a new account that will be the node account id
-            var resp = new AccountCreateTransaction()
-                    .setKey(originalOperatorKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(1))
-                    .execute(client);
-
-            var receipt = resp.setValidateStatus(true).getReceipt(client);
-            var newNodeAccountID = receipt.accountId;
+            var newNodeAccountID = createAccount(client, originalOperatorKey.getPublicKey(), Hbar.from(1));
             assertThat(newNodeAccountID).isNotNull();
 
             // Update node 0's account id (0.0.3 -> newNodeAccountID)
-            resp = new NodeUpdateTransaction()
+            var resp = new NodeUpdateTransaction()
                     .setNodeId(0)
                     .setDescription("testUpdated")
                     .setAccountId(newNodeAccountID)
                     .execute(client);
 
-            receipt = resp.setValidateStatus(true).getReceipt(client);
+            var receipt = resp.setValidateStatus(true).getReceipt(client);
             assertThat(receipt.status).isEqualTo(Status.SUCCESS);
 
             // Wait for mirror node to import data
@@ -488,28 +439,10 @@ void testSubsequentTransactionWithNewNodeAccountIdSucceeds() throws Exception {
             // Given: Successfully handled transaction with outdated node account ID
             // This transaction targets old node account ID (0.0.3) and new node account ID (0.0.4)
             // Node 0.0.3 will fail with INVALID_NODE_ACCOUNT and SDK will retry with 0.0.4
-            var newAccountKey = PrivateKey.generateED25519();
-            resp = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setNodeAccountIds(List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)))
-                    .execute(client);
-
-            // Verify the SDK handled the error and completed the transaction
-            assertThat(resp).isNotNull();
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+            executeAccountCreate(client, List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)));
 
             // When: Subsequent transaction targets the NEW node account ID directly
-            var anotherAccountKey = PrivateKey.generateED25519();
-            resp = new AccountCreateTransaction()
-                    .setKey(anotherAccountKey.getPublicKey())
-                    .setNodeAccountIds(List.of(newNodeAccountID))
-                    .execute(client);
-
-            // Then: The transaction should succeed without any errors
-            assertThat(resp).isNotNull();
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+            executeAccountCreate(client, List.of(newNodeAccountID));
 
             // Cleanup: Revert the node account id (newNodeAccountID -> 0.0.3)
             resp = new NodeUpdateTransaction()
@@ -528,98 +461,76 @@ void testSubsequentTransactionWithNewNodeAccountIdSucceeds() throws Exception {
     @DisplayName(
             "Given an SDK receives INVALID_NODE_ACCOUNT for a node, when updating its network configuration, then the SDK updates its network with the latest node account IDs for subsequent transactions")
     void testSdkUpdatesNetworkConfigurationOnInvalidNodeAccount() throws Exception {
-        // Set the network
         var network = new HashMap<String, AccountId>();
         network.put("localhost:50211", new AccountId(0, 0, 3));
         network.put("localhost:51211", new AccountId(0, 0, 4));
 
         try (var client =
                 Client.forNetwork(network).setTransportSecurity(false).setMirrorNetwork(List.of("localhost:5600"))) {
 
-            // Set the operator to be account 0.0.2
             var originalOperatorKey = PrivateKey.fromString(
                     "302e020100300506032b65700422042091132178e72057a1d7528025956fe39b0b847f200ab59b2fdd367017f3087137");
             client.setOperator(new AccountId(0, 0, 2), originalOperatorKey);
 
-            // Given: Verify initial network configuration
-            var initialNetwork = client.getNetwork();
-            assertThat(initialNetwork).containsEntry("localhost:50211", new AccountId(0, 0, 3));
-            assertThat(initialNetwork).containsEntry("localhost:51211", new AccountId(0, 0, 4));
-
-            // Create a new account that will be the node account id
-            var resp = new AccountCreateTransaction()
-                    .setKey(originalOperatorKey.getPublicKey())
-                    .setInitialBalance(Hbar.from(1))
-                    .execute(client);
-
-            var receipt = resp.setValidateStatus(true).getReceipt(client);
-            var newNodeAccountID = receipt.accountId;
+            var newNodeAccountID = createAccount(client, originalOperatorKey.getPublicKey(), Hbar.from(1));
             assertThat(newNodeAccountID).isNotNull();
 
-            // Update node 0's account id (0.0.3 -> newNodeAccountID)
-            resp = new NodeUpdateTransaction()
-                    .setNodeId(0)
-                    .setDescription("testUpdated")
-                    .setAccountId(newNodeAccountID)
-                    .execute(client);
-
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+            updateNodeAccountId(client, 0, newNodeAccountID, null);
 
-            // Wait for mirror node to import data
             Thread.sleep(10000);
 
-            // When: Submit transaction with outdated node account ID (0.0.3)
-            // This will trigger INVALID_NODE_ACCOUNT error and the SDK should update its network
-            var newAccountKey = PrivateKey.generateED25519();
-            resp = new AccountCreateTransaction()
-                    .setKey(newAccountKey.getPublicKey())
-                    .setNodeAccountIds(List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)))
-                    .execute(client);
+            // Trigger INVALID_NODE_ACCOUNT error and retry
+            executeAccountCreate(client, List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)));
 
-            // Verify the transaction succeeded (SDK retried with another node)
-            assertThat(resp).isNotNull();
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
-
-            // Then: Verify the SDK has updated its network configuration
-            // The network should now contain the new node account ID
-            var updatedNetwork = client.getNetwork();
-
-            // The network map should have been updated with the new account ID
-            // Note: The address book update happens asynchronously, so we verify
-            // that subsequent transactions can successfully target the new account ID
-
-            // Verify subsequent transaction with the new node account ID succeeds
-            var anotherAccountKey = PrivateKey.generateED25519();
-            resp = new AccountCreateTransaction()
-                    .setKey(anotherAccountKey.getPublicKey())
-                    .setNodeAccountIds(List.of(newNodeAccountID))
-                    .execute(client);
-
-            assertThat(resp).isNotNull();
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+            // Verify subsequent transaction with new node account ID
+            executeAccountCreate(client, List.of(newNodeAccountID));
 
             // Verify the network configuration now includes the new account ID
-            // This confirms the SDK successfully updated its network from the address book
             var finalNetwork = client.getNetwork();
             var hasNewAccountId =
                     finalNetwork.values().stream().anyMatch(accountId -> accountId.equals(newNodeAccountID));
             assertThat(hasNewAccountId)
                     .as("Client network should contain the new node account ID after address book update")
                     .isTrue();
 
-            // Cleanup: Revert the node account id (newNodeAccountID -> 0.0.3)
-            resp = new NodeUpdateTransaction()
-                    .setNodeId(0)
-                    .setNodeAccountIds(List.of(newNodeAccountID))
-                    .setDescription("testUpdated")
-                    .setAccountId(new AccountId(0, 0, 3))
-                    .execute(client);
+            // Cleanup
+            updateNodeAccountId(client, 0, new AccountId(0, 0, 3), List.of(newNodeAccountID));
+        }
+    }
 
-            receipt = resp.setValidateStatus(true).getReceipt(client);
-            assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+    private AccountId createAccount(Client client, Key key, Hbar initialBalance) throws Exception {
+        var resp = new AccountCreateTransaction()
+                .setKey(key)
+                .setInitialBalance(initialBalance)
+                .execute(client);
+        return resp.setValidateStatus(true).getReceipt(client).accountId;
+    }
+
+    private void updateNodeAccountId(Client client, long nodeId, AccountId newAccountId, List<AccountId> nodeAccountIds)
+            throws Exception {
+        var transaction = new NodeUpdateTransaction()
+                .setNodeId(nodeId)
+                .setDescription("testUpdated")
+                .setAccountId(newAccountId);
+
+        if (nodeAccountIds != null) {
+            transaction.setNodeAccountIds(nodeAccountIds);
         }
+
+        var resp = transaction.execute(client);
+        var receipt = resp.setValidateStatus(true).getReceipt(client);
+        assertThat(receipt.status).isEqualTo(Status.SUCCESS);
+    }
+
+    private void executeAccountCreate(Client client, List<AccountId> nodeAccountIds) throws Exception {
+        var newAccountKey = PrivateKey.generateED25519();
+        var resp = new AccountCreateTransaction()
+                .setKey(newAccountKey.getPublicKey())
+                .setNodeAccountIds(nodeAccountIds)
+                .execute(client);
+
+        assertThat(resp).isNotNull();
+        var receipt = resp.setValidateStatus(true).getReceipt(client);
+        assertThat(receipt.status).isEqualTo(Status.SUCCESS);
     }
 }