Quality fixes in BrokerService and BrokerServiceTests

Author: jbern0rd

src/main/java/com/iexec/blockchain/broker/BrokerService.java

@@ -95,7 +95,8 @@ public String matchOrders(BrokerOrder brokerOrder) {
         RequestOrder requestOrder = brokerOrder.getRequestOrder();
         final boolean withDataset = withDataset(requestOrder.getDataset());
         BigInteger datasetPrice = withDataset ? datasetOrder.getDatasetprice() : BigInteger.ZERO;
-        if (!hasRequesterAcceptedPrices(brokerOrder.getRequestOrder(),
+        if (!hasRequesterAcceptedPrices(
+                requestOrder,
                 appOrder.getAppprice(),
                 workerpoolOrder.getWorkerpoolprice(),
                 datasetPrice,
@@ -112,7 +113,7 @@ public String matchOrders(BrokerOrder brokerOrder) {
                 datasetPrice.longValue())) {
             throw new IllegalStateException("Deposit too low");
         }
-        String beneficiary = brokerOrder.getRequestOrder().getBeneficiary();
+        String beneficiary = requestOrder.getBeneficiary();
         String messageDetails = MessageFormat.format("requester:{0}, beneficiary:{1}, pool:{2}, app:{3}",
                 requestOrder.getRequester(), beneficiary, workerpoolOrder.getWorkerpool(), appOrder.getApp());
         if (withDataset) {
@@ -140,9 +141,10 @@ Optional<String> fireMatchOrders(
             log.info("block {}, hash {}, status {}", receipt.getBlockNumber(), receipt.getTransactionHash(), receipt.getStatus());
             log.info("logs count {}", receipt.getLogs().size());
 
+            String workerpoolAddress = workerpoolOrder.getWorkerpool();
             List<String> events = IexecHubContract.getSchedulerNoticeEvents(receipt)
                     .stream()
-                    .filter(event -> workerpoolOrder.getWorkerpool().equals(event.workerpool))
+                    .filter(event -> workerpoolAddress.equals(event.workerpool))
                     .map(event -> BytesUtils.bytesToString(event.dealid))
                     .collect(Collectors.toList());
             log.info("events count {}", events.size());

src/test/java/com/iexec/blockchain/broker/BrokerServiceTests.java

@@ -19,39 +19,50 @@
 import com.iexec.blockchain.tool.IexecHubService;
 import com.iexec.common.sdk.broker.BrokerOrder;
 import com.iexec.commons.poco.chain.ChainAccount;
+import com.iexec.commons.poco.contract.generated.IexecHubContract;
 import com.iexec.commons.poco.order.*;
 import com.iexec.commons.poco.utils.BytesUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 import org.springframework.boot.test.system.CapturedOutput;
 import org.springframework.boot.test.system.OutputCaptureExtension;
 import org.web3j.crypto.Credentials;
 import org.web3j.crypto.ECKeyPair;
 import org.web3j.crypto.Keys;
+import org.web3j.protocol.core.RemoteFunctionCall;
+import org.web3j.protocol.core.methods.response.TransactionReceipt;
 
+import java.io.IOException;
 import java.math.BigInteger;
 import java.text.MessageFormat;
 import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 @ExtendWith(OutputCaptureExtension.class)
 class BrokerServiceTests {
 
+    @Mock
     private IexecHubService iexecHubService;
     private BrokerService brokerService;
 
+    @Mock
+    RemoteFunctionCall<TransactionReceipt> remoteCall;
+
     private static final ChainAccount deposit = ChainAccount.builder().deposit(100L).build();
     private static final ChainAccount emptyDeposit = ChainAccount.builder().deposit(0L).build();
 
     @BeforeEach
     void init() {
-        iexecHubService = mock(IexecHubService.class);
+        MockitoAnnotations.openMocks(this);
         brokerService = new BrokerService(iexecHubService);
     }
 
@@ -100,12 +111,10 @@ WorkerpoolOrder generateWorkerpoolOrder() {
                 .build();
     }
 
-    BrokerOrder generateBrokerOrder(boolean withDataset) {
-        AppOrder appOrder = generateAppOrder();
-        WorkerpoolOrder workerpoolOrder = generateWorkerpoolOrder();
-        DatasetOrder datasetOrder = generateDatasetOrder(withDataset);
+    RequestOrder generateRequestOrder(
+            AppOrder appOrder, DatasetOrder datasetOrder, WorkerpoolOrder workerpoolOrder) {
         String requestAddress = generateEthereumAddress();
-        RequestOrder requestOrder = RequestOrder.builder()
+        return RequestOrder.builder()
                 .app(appOrder.getApp())
                 .appmaxprice(BigInteger.ONE)
                 .dataset(datasetOrder.getDataset())
@@ -123,6 +132,14 @@ BrokerOrder generateBrokerOrder(boolean withDataset) {
                 .salt(BytesUtils.toByte32HexString(1))
                 .sign("sign")
                 .build();
+    }
+
+    BrokerOrder generateBrokerOrder(boolean withDataset) {
+        AppOrder appOrder = generateAppOrder();
+        WorkerpoolOrder workerpoolOrder = generateWorkerpoolOrder();
+        DatasetOrder datasetOrder = generateDatasetOrder(withDataset);
+        RequestOrder requestOrder = generateRequestOrder(
+                appOrder, datasetOrder, workerpoolOrder);
         return BrokerOrder.builder()
                 .appOrder(appOrder)
                 .datasetOrder(datasetOrder)
@@ -397,36 +414,39 @@ void shouldNotMatchOrderAndReturnEmptyStringWithoutDataset(CapturedOutput output
 
     //region fireMatchOrders
     @Test
-    void shouldFailToMatchOrdersWithDataset() {
+    void shouldFailToMatchOrdersWithDataset() throws Exception {
         AppOrder appOrder = generateAppOrder();
         DatasetOrder datasetOrder = generateDatasetOrder(true);
         WorkerpoolOrder workerpoolOrder = generateWorkerpoolOrder();
-        RequestOrder requestOrder = RequestOrder.builder()
-                .requester(generateEthereumAddress())
-                .beneficiary(generateEthereumAddress())
-                .app(appOrder.getApp())
-                .dataset(datasetOrder.getDataset())
-                .workerpool(workerpoolOrder.getWorkerpool())
-                .build();
+        RequestOrder requestOrder = generateRequestOrder(
+                appOrder, datasetOrder, workerpoolOrder);
+        IexecHubContract iexecHubContract = mock(IexecHubContract.class);
+        when(iexecHubService.getHubContract()).thenReturn(iexecHubContract);
+        when(iexecHubContract.matchOrders(any(), any(), any(), any())).thenReturn(remoteCall);
+        when(remoteCall.send()).thenThrow(IOException.class);
+        assertThat(brokerService.fireMatchOrders(appOrder, datasetOrder,workerpoolOrder, requestOrder))
+                .isEmpty();
         assertThat(brokerService.fireMatchOrders(appOrder, datasetOrder, workerpoolOrder, requestOrder))
                 .isEmpty();
     }
 
     @Test
-    void shouldFailToMatchOrdersWithoutDataset() {
+    void shouldFailToMatchOrdersWithoutDataset() throws Exception {
         AppOrder appOrder = generateAppOrder();
         DatasetOrder datasetOrder = generateDatasetOrder(false);
         WorkerpoolOrder workerpoolOrder = generateWorkerpoolOrder();
-        RequestOrder requestOrder = RequestOrder.builder()
-                .requester(generateEthereumAddress())
-                .beneficiary(generateEthereumAddress())
-                .app(appOrder.getApp())
-                .workerpool(workerpoolOrder.getWorkerpool())
-                .workerpoolmaxprice(BigInteger.ONE)
-                .build();
+        RequestOrder requestOrder = generateRequestOrder(
+                appOrder, datasetOrder, workerpoolOrder);
+        IexecHubContract iexecHubContract = mock(IexecHubContract.class);
+        when(iexecHubService.getHubContract()).thenReturn(iexecHubContract);
+        when(iexecHubContract.matchOrders(any(), any(), any(), any())).thenReturn(remoteCall);
+        when(remoteCall.send()).thenThrow(IOException.class);
+        assertThat(brokerService.fireMatchOrders(appOrder, datasetOrder,workerpoolOrder, requestOrder))
+                .isEmpty();
         assertThat(brokerService.fireMatchOrders(appOrder, datasetOrder, workerpoolOrder, requestOrder))
                 .isEmpty();
     }
+
     //endregion
 
     //region hasRequesterAcceptedPrices