package jnpf.flowable.service.dev;

import jnpf.base.model.flow.FlowFormDataModel;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.*;
import jnpf.flowable.model.task.FlowModel;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.*;
import jnpf.flowable.service.OperatorService;
import jnpf.flowable.util.*;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import java.util.*;
import static org.junit.Assert.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

public class DevApprovalStepTest {
    @Test public void savesThroughNativeFormBeforeAuditAndAlwaysCleansActorScope() throws Exception {
        OperatorUtil engine = mock(OperatorUtil.class); ServiceUtil forms = mock(ServiceUtil.class);
        OperatorService operators = mock(OperatorService.class);
        DevApprovalStep step = new DevApprovalStep(engine, forms, operators);
        OperatorEntity operator = new OperatorEntity(); operator.setId("op"); operator.setTaskId("task"); operator.setNodeCode("node");
        TaskEntity task = new TaskEntity(); task.setId("task"); task.setFlowId("flow");
        TemplateNodeEntity definition = new TemplateNodeEntity(); definition.setNodeCode("node"); definition.setFormId("form");
        NodeModel node = new NodeModel(); node.setFormOperates(List.of(Map.of("id", "reason", "required", true, "write", false)));
        FlowModel model = new FlowModel(); model.setTaskEntity(task); model.setNodes(Map.of("node", node)); model.setNodeEntityList(List.of(definition));
        Map<String,Object> values = new HashMap<>(Map.of("biz_sign", "real-sign", "reason", "已输入")); model.setFormData(values);
        when(forms.infoData("form", "task")).thenReturn(values);
        doAnswer(call -> {
            assertTrue(DevApprovalActor.isActing("op", "signer"));
            assertFalse(DevApprovalActor.isActing("other", "signer"));
            return null;
        }).when(forms).saveOrUpdateFormData(any());
        try {
            step.approve(operator, model, "signer");
            assertFalse(DevApprovalActor.active());
            var order = inOrder(forms, engine);
            ArgumentCaptor<FlowFormDataModel> capture = ArgumentCaptor.forClass(FlowFormDataModel.class);
            order.verify(forms).saveOrUpdateFormData(capture.capture());
            order.verify(forms).infoData("form", "task");
            order.verify(engine).audit(operator, model);
            order.verify(forms).handleFormData("flow", true);
            assertEquals("op", capture.getValue().getWorkflowOperatorId());
            assertFalse(Boolean.TRUE.equals(capture.getValue().getSkipRequiredValidation()));
            assertEquals(true, capture.getValue().getFormOperates().get(0).get("write"));
            assertEquals(false, node.getFormOperates().get(0).get("write"));
            reset(engine); doThrow(new WorkFlowException("native failure")).when(forms).saveOrUpdateFormData(any());
            try { step.approve(operator, model, "signer"); fail(); } catch (WorkFlowException expected) { }
            verifyNoInteractions(engine); assertFalse(DevApprovalActor.active());
        } finally { FlowContextHolder.clearAll(); }
    }
}