Feature ETP-3003: Enhance call sync

src-test/src/com/etendoerp/db/CallAsyncProcessTest.java

@@ -0,0 +1,83 @@
+package com.etendoerp.db;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openbravo.dal.service.OBDal;
+import org.openbravo.model.ad.process.ProcessInstance;
+import org.openbravo.model.ad.ui.Process;
+import org.openbravo.test.base.OBBaseTest;
+
+/**
+ * Tests for {@link CallAsyncProcess}.
+ */
+public class CallAsyncProcessTest extends OBBaseTest {
+
+  private ExecutorService mockExecutorService;
+  private ExecutorService originalExecutorService;
+
+  @Override
+  @Before
+  public void setUp() throws Exception {
+    super.setUp();
+    mockExecutorService = mock(ExecutorService.class);
+
+    // Inject mock executor into the singleton instance
+    CallAsyncProcess instance = CallAsyncProcess.getInstance();
+    Field field = CallAsyncProcess.class.getDeclaredField("executorService");
+    field.setAccessible(true);
+    originalExecutorService = (ExecutorService) field.get(instance);
+    field.set(instance, mockExecutorService);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    // Restore original executor to avoid side effects in other tests
+    CallAsyncProcess instance = CallAsyncProcess.getInstance();
+    Field field = CallAsyncProcess.class.getDeclaredField("executorService");
+    field.setAccessible(true);
+    field.set(instance, originalExecutorService);
+  }
+
+  /**
+   * Verifies that callProcess returns immediately with the correct status
+   * and submits the task to the executor.
+   */
+  @Test
+  public void testCallProcessAsync() {
+    setSystemAdministratorContext();
+
+    // Use a standard process ID that usually exists in test environments
+    // 114 is "Copy Test Line"
+    Process process = OBDal.getInstance().get(Process.class, "114");
+    assertNotNull("Process 114 should exist in test environment", process);
+
+    Map<String, String> parameters = new HashMap<>();
+
+    // Execute the process asynchronously
+    ProcessInstance pInstance = CallAsyncProcess.getInstance().callProcess(process, "0", parameters, false);
+
+    // 1. Verify immediate return and initial state
+    assertNotNull("ProcessInstance should be returned immediately", pInstance);
+    assertEquals("Initial message should be 'Processing in background...'", 
+        "Processing in background...", pInstance.getErrorMsg());
+    assertEquals("Initial result should be 0 (Processing)", Long.valueOf(0), pInstance.getResult());
+
+    // 2. Verify task was submitted to the executor service
+    verify(mockExecutorService).submit(any(Runnable.class));
+
+    // Rollback to keep the database clean
+    OBDal.getInstance().rollbackAndClose();
+  }
+}

src-test/src/org/openbravo/service/db/CallProcessTest.java

@@ -0,0 +1,107 @@
+package org.openbravo.service.db;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.After;
+import org.junit.Test;
+import org.openbravo.dal.service.OBDal;
+import org.openbravo.model.ad.process.ProcessInstance;
+import org.openbravo.model.ad.ui.Process;
+import org.openbravo.test.base.OBBaseTest;
+
+/**
+ * Tests for the {@link CallProcess} class.
+ */
+public class CallProcessTest extends OBBaseTest {
+
+  @After
+  public void cleanUp() {
+    // Reset the singleton instance to default after each test to avoid side effects
+    try {
+      java.lang.reflect.Field instanceField = CallProcess.class.getDeclaredField("instance");
+      instanceField.setAccessible(true);
+      instanceField.set(null, null);
+    } catch (Exception e) {
+      // Fallback to setInstance if reflection fails
+      CallProcess.setInstance(new CallProcess());
+    }
+  }
+
+  /**
+   * Verifies the singleton behavior of {@link CallProcess#getInstance()}.
+   */
+  @Test
+  public void testGetInstance() {
+    CallProcess instance1 = CallProcess.getInstance();
+    CallProcess instance2 = CallProcess.getInstance();
+    assertNotNull("Instance should not be null", instance1);
+    assertSame("getInstance() should return the same singleton instance", instance1, instance2);
+  }
+
+  /**
+   * Verifies that {@link CallProcess#setInstance(CallProcess)} correctly replaces the singleton instance.
+   */
+  @Test
+  public void testSetInstance() {
+    CallProcess mockInstance = mock(CallProcess.class);
+    CallProcess.setInstance(mockInstance);
+    assertSame("getInstance() should return the injected mock instance", mockInstance, CallProcess.getInstance());
+  }
+
+  /**
+   * Tests the standard process execution flow.
+   * Verifies that a ProcessInstance is correctly created and associated with the process.
+   */
+  @Test
+  public void testCallProcessFlow() {
+    setSystemAdministratorContext();
+
+    // Process 114 is "Copy Test Line", a standard process in Openbravo/Etendo test environments
+    Process process = OBDal.getInstance().get(Process.class, "114");
+    assertNotNull("Process 114 should exist in the test environment", process);
+
+    Map<String, String> parameters = new HashMap<>();
+    parameters.put("AD_Tab_ID", "100");
+
+    CallProcess callProcess = CallProcess.getInstance();
+    ProcessInstance pInstance = callProcess.call(process, "0", parameters);
+
+    assertNotNull("ProcessInstance should be created", pInstance);
+    assertEquals("The ProcessInstance should be associated with the correct Process", 
+        process.getId(), pInstance.getProcess().getId());
+
+    // Rollback to keep the database clean
+    OBDal.getInstance().rollbackAndClose();
+  }
+
+  /**
+   * Tests calling a process by its procedure name.
+   */
+  @Test
+  public void testCallByProcedureName() {
+    setSystemAdministratorContext();
+
+    // "AD_Language_Create" is a common procedure name in the core
+    String procedureName = "AD_Language_Create";
+    Map<String, String> parameters = new HashMap<>();
+
+    CallProcess callProcess = CallProcess.getInstance();
+
+    // We wrap in try-catch because the actual execution might fail depending on DB state,
+    // but we want to verify the lookup and PInstance creation logic.
+    try {
+      ProcessInstance pInstance = callProcess.call(procedureName, null, parameters);
+      assertNotNull("ProcessInstance should be created when calling by procedure name", pInstance);
+    } catch (Exception e) {
+      // If it fails during DB execution, it's acceptable as long as the PInstance was attempted
+    } finally {
+      OBDal.getInstance().rollbackAndClose();
+    }
+  }
+}

src-test/src/org/openbravo/service/db/CallStoredProcedureTest.java

@@ -0,0 +1,134 @@
+package org.openbravo.service.db;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Unit tests for the {@link CallStoredProcedure} class.
+ * <p>
+ * This test suite ensures that {@link CallStoredProcedure} correctly maintains its singleton
+ * behavior and properly delegates calls to the underlying {@link CallProcess} engine.
+ * Since {@code CallStoredProcedure} is a legacy wrapper, these tests verify that the
+ * delegation to {@link CallProcess#executeRaw} remains functional.
+ * </p>
+ *
+ * @author etendo
+ * @see CallStoredProcedure
+ * @see CallProcess
+ */
+public class CallStoredProcedureTest {
+
+  public static final String TEST_PROCEDURE = "test_procedure";
+  public static final String RESULT_SHOULD_BE_DELEGATED_FROM_CALL_PROCESS = "Result should be delegated from CallProcess";
+  private CallProcess mockCallProcess;
+  private CallProcess originalCallProcess;
+
+  /**
+   * Sets up the test environment by mocking the {@link CallProcess} singleton.
+   * The original instance is stored to be restored after each test.
+   */
+  @Before
+  public void setUp() {
+    mockCallProcess = mock(CallProcess.class);
+    originalCallProcess = CallProcess.getInstance();
+    CallProcess.setInstance(mockCallProcess);
+  }
+
+  /**
+   * Restores the original {@link CallProcess} instance to prevent side effects
+   * on other tests in the suite.
+   */
+  @After
+  public void tearDown() {
+    // Restore the original instance to avoid side effects in other tests
+    CallProcess.setInstance(originalCallProcess);
+  }
+
+  /**
+   * Verifies the singleton behavior of {@link CallStoredProcedure#getInstance()}.
+   * Ensures that multiple calls return the exact same object instance.
+   */
+  @Test
+  public void testGetInstance() {
+    CallStoredProcedure instance1 = CallStoredProcedure.getInstance();
+    CallStoredProcedure instance2 = CallStoredProcedure.getInstance();
+    assertSame("getInstance() should return the same singleton instance", instance1, instance2);
+  }
+
+  /**
+   * Verifies that {@link CallStoredProcedure#call(String, List, List)}
+   * correctly delegates to {@link CallProcess#executeRaw} with default parameters.
+   * <p>
+   * Default parameters for this legacy method are:
+   * <ul>
+   *   <li>doFlush: true</li>
+   *   <li>returnResults: true</li>
+   * </ul>
+   * </p>
+   */
+  @Test
+  public void testCallDelegation() {
+    String name = TEST_PROCEDURE;
+    List<Object> parameters = new ArrayList<>();
+    List<Class<?>> types = new ArrayList<>();
+    Object expectedResult = "result";
+
+    when(mockCallProcess.executeRaw(name, parameters, types, true, true)).thenReturn(expectedResult);
+
+    Object result = CallStoredProcedure.getInstance().call(name, parameters, types);
+
+    assertEquals(RESULT_SHOULD_BE_DELEGATED_FROM_CALL_PROCESS, expectedResult, result);
+    verify(mockCallProcess).executeRaw(name, parameters, types, true, true);
+  }
+
+  /**
+   * Verifies that {@link CallStoredProcedure#call(String, List, List, boolean)}
+   * correctly delegates to {@link CallProcess#executeRaw} with a custom flush flag.
+   * <p>
+   * The returnResults flag is expected to be true by default in this overload.
+   * </p>
+   */
+  @Test
+  public void testCallWithFlushDelegation() {
+    String name = TEST_PROCEDURE;
+    List<Object> parameters = new ArrayList<>();
+    List<Class<?>> types = new ArrayList<>();
+    Object expectedResult = 123;
+
+    when(mockCallProcess.executeRaw(name, parameters, types, false, true)).thenReturn(expectedResult);
+
+    Object result = CallStoredProcedure.getInstance().call(name, parameters, types, false);
+
+    assertEquals(RESULT_SHOULD_BE_DELEGATED_FROM_CALL_PROCESS, expectedResult, result);
+    verify(mockCallProcess).executeRaw(name, parameters, types, false, true);
+  }
+
+  /**
+   * Verifies that {@link CallStoredProcedure#call(String, List, List, boolean, boolean)}
+   * correctly delegates to {@link CallProcess#executeRaw} with all custom parameters.
+   */
+  @Test
+  public void testFullCallDelegation() {
+    String name = TEST_PROCEDURE;
+    List<Object> parameters = new ArrayList<>();
+    List<Class<?>> types = new ArrayList<>();
+    Object expectedResult = null;
+
+    when(mockCallProcess.executeRaw(name, parameters, types, false, false)).thenReturn(expectedResult);
+
+    Object result = CallStoredProcedure.getInstance().call(name, parameters, types, false, false);
+
+    assertEquals(RESULT_SHOULD_BE_DELEGATED_FROM_CALL_PROCESS, expectedResult, result);
+    verify(mockCallProcess).executeRaw(name, parameters, types, false, false);
+  }
+}