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

@@ -528,98 +528,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());
             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);
-
-            // 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
+            // Trigger INVALID_NODE_ACCOUNT error and retry
+            executeAccountCreate(client, List.of(new AccountId(0, 0, 3), new AccountId(0, 0, 4)));
 
-            // 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) throws Exception {
+        var resp = new AccountCreateTransaction()
+                .setKey(key)
+                .setInitialBalance(Hbar.from(1))
+                .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);
     }
 }