GenericEmergencyProcedureTest.java

/*
 * To change this template, choose Tools | Templates and open the template in
 * the editor.
 */
package com.wordpress.salaboy.grid;

import com.wordpress.salaboy.context.tracking.ContextTrackingProvider;
import com.wordpress.salaboy.context.tracking.ContextTrackingService;
import com.wordpress.salaboy.messaging.*;
import com.wordpress.salaboy.model.*;
import com.wordpress.salaboy.model.events.AllProceduresEndedEvent;
import com.wordpress.salaboy.model.messages.AsyncProcedureStartMessage;
import com.wordpress.salaboy.model.persistence.PersistenceService;
import com.wordpress.salaboy.model.persistence.PersistenceServiceProvider;
import com.wordpress.salaboy.services.GenericEmergencyProcedureImpl;
import com.wordpress.salaboy.services.HumanTaskServerService;
import com.wordpress.salaboy.services.ProceduresMGMTService;
import java.io.*;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.drools.grid.SocketService;
import org.hornetq.api.core.HornetQException;
import org.jbpm.process.workitem.wsht.BlockingGetTaskResponseHandler;
import org.jbpm.task.AccessType;
import org.jbpm.task.AsyncTaskService;
import org.jbpm.task.Content;
import org.jbpm.task.Task;
import org.jbpm.task.query.TaskSummary;
import org.jbpm.task.service.ContentData;
import org.jbpm.task.service.responsehandlers.BlockingGetContentResponseHandler;
import org.jbpm.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
import org.jbpm.task.service.responsehandlers.BlockingTaskSummaryResponseHandler;
import static org.junit.Assert.*;
import org.junit.*;

/**
 *
 * @author salaboy
 */
public class GenericEmergencyProcedureTest extends GridBaseTest {

    private MessageConsumer consumer;
    private AsyncTaskService client;
    private MessageConsumerWorker asynchProcedureStartWorker;
    private PersistenceService persistenceService;
    private ContextTrackingService trackingService; 

    public GenericEmergencyProcedureTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() throws Exception {
        persistenceService = PersistenceServiceProvider.getPersistenceService();
        trackingService = ContextTrackingProvider.getTrackingService();

        
        HumanTaskServerService.getInstance().initTaskServer();

        MessageServerSingleton.getInstance().start();

        consumer = MessageFactory.createMessageConsumer("IncomingCall");


        this.coreServicesMap = new HashMap();


        createRemoteNode();


        client = HumanTaskServerService.getInstance().initTaskClient();


        
    }

    @After
    public void tearDown() throws Exception {

        HumanTaskServerService.getInstance().stopTaskServer();

        MessageServerSingleton.getInstance().stop();
        if (remoteN1 != null) {
            remoteN1.dispose();
        }
        if (grid1 != null) {
            grid1.get(SocketService.class).close();
        }
        PersistenceServiceProvider.clear();
        ContextTrackingProvider.clear();

    }

    @Test
    public void genericEmergencyProcedureTest() throws HornetQException, InterruptedException, IOException, ClassNotFoundException {

        asynchProcedureStartWorker = new MessageConsumerWorker("asyncProcedureStartCoreServer", new MessageConsumerWorkerHandler<AsyncProcedureStartMessage>() {

            @Override
            public void handleMessage(AsyncProcedureStartMessage message) {
                System.out.println(">>>>>>>>>>>Creating a new Procedure = " + message.getProcedureName());
                try {
                    ProceduresMGMTService.getInstance().newRequestedProcedure(message.getEmergencyId(), message.getProcedureName(), message.getParameters());
                } catch (IOException ex) {
                    Logger.getLogger(GenericEmergencyProcedureTest.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        });

        asynchProcedureStartWorker.start();




        MessageProducer producer = MessageFactory.createMessageProducer();
        Call initialCall = new Call(1, 2, new Date());
       
        producer.sendMessage(initialCall);
        producer.stop();

        Call call = (Call) consumer.receiveMessage();
        assertNotNull(call);

        GenericEmergencyProcedureImpl.getInstance().newPhoneCall(call);

        Thread.sleep(5000);

        doOperatorTask();

        //QUERY TO SEE THAT WE HAVE AN EMERGENCY ATTACHED TO THE CALL

        Thread.sleep(2000);

        doControlTask();

        Thread.sleep(6000);
        //I should have one task here, that has been created by the specific procedure started
        doGarageTask();

        Thread.sleep(3000);
        // I can asume that all the procedures are ended, we need to delegate this to the external component
        AllProceduresEndedEvent allProceduresEndedEvent = new AllProceduresEndedEvent(null, new ArrayList<String>());
        GenericEmergencyProcedureImpl.getInstance().allProceduresEnededNotification(allProceduresEndedEvent);
        // We should see the report in the console
        Thread.sleep(10000);

    }

    private void doOperatorTask() throws ClassNotFoundException, IOException {
        BlockingTaskSummaryResponseHandler handler = new BlockingTaskSummaryResponseHandler();
        client.getTasksAssignedAsPotentialOwner("operator", "en-UK", handler);
        List<TaskSummary> sums = handler.getResults();
        assertNotNull(sums);
        assertEquals(1, sums.size());

        BlockingTaskOperationResponseHandler startTaskOperationHandler = new BlockingTaskOperationResponseHandler();
        client.start(sums.get(0).getId(), "operator", startTaskOperationHandler);

        BlockingGetTaskResponseHandler getTaskHandler = new BlockingGetTaskResponseHandler();
        client.getTask(sums.get(0).getId(), getTaskHandler);
        Task operatorTask = getTaskHandler.getTask();

        BlockingGetContentResponseHandler getContentHandler = new BlockingGetContentResponseHandler();
        client.getContent(operatorTask.getTaskData().getDocumentContentId(), getContentHandler);
        Content content = getContentHandler.getContent();

        assertNotNull(content);

        ByteArrayInputStream bais = new ByteArrayInputStream(content.getContent());
        ObjectInputStream ois = new ObjectInputStream(bais);
        Map<String, Object> deserializedContent = (Map<String, Object>) ois.readObject();
        Call restoredCall = (Call) deserializedContent.get("call");
        persistenceService.storeCall(restoredCall);

      
        Emergency emergency = new Emergency();
      
        emergency.setCall(restoredCall);
      
        emergency.setLocation(new Location(1, 2));
        emergency.setType(Emergency.EmergencyType.HEART_ATTACK);
        emergency.setNroOfPeople(1);
        persistenceService.storeEmergency(emergency);
        
        trackingService.attachEmergency(restoredCall.getId(), emergency.getId());

        Map<String, Object> info = new HashMap<String, Object>();
        info.put("emergency", emergency);


        ContentData result = new ContentData();
        result.setAccessType(AccessType.Inline);
        result.setType("java.util.Map");
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bos);
        out.writeObject(info);
        out.close();
        result.setContent(bos.toByteArray());

        BlockingTaskOperationResponseHandler completeTaskOperationHandler = new BlockingTaskOperationResponseHandler();
        client.complete(sums.get(0).getId(), "operator", result, completeTaskOperationHandler);



    }

    private void doControlTask() throws IOException, ClassNotFoundException {
        BlockingTaskSummaryResponseHandler handler = new BlockingTaskSummaryResponseHandler();
        client.getTasksAssignedAsPotentialOwner("control", "en-UK", handler);
        List<TaskSummary> sums = handler.getResults();
        assertNotNull(sums);
        assertEquals(1, sums.size());

        BlockingTaskOperationResponseHandler startTaskOperationHandler = new BlockingTaskOperationResponseHandler();
        client.start(sums.get(0).getId(), "control", startTaskOperationHandler);

        BlockingGetTaskResponseHandler getTaskHandler = new BlockingGetTaskResponseHandler();
        client.getTask(sums.get(0).getId(), getTaskHandler);
        Task controlTask = getTaskHandler.getTask();

        BlockingGetContentResponseHandler getContentHandler = new BlockingGetContentResponseHandler();
        client.getContent(controlTask.getTaskData().getDocumentContentId(), getContentHandler);
        Content content = getContentHandler.getContent();

        assertNotNull(content);

        ByteArrayInputStream bais = new ByteArrayInputStream(content.getContent());
        ObjectInputStream ois = new ObjectInputStream(bais);
        Map<String, Object> deserializedContent = (Map<String, Object>) ois.readObject();
        Emergency retrivedEmergency = (Emergency) deserializedContent.get("emergency");
        assertNotNull(retrivedEmergency);
        ActivePatients retrivedActivePatients = (ActivePatients) deserializedContent.get("activePatients");
        assertNotNull(retrivedActivePatients);
        assertEquals(1, retrivedActivePatients.size());
        SuggestedProcedures retrivedSuggestedProcedures = (SuggestedProcedures) deserializedContent.get("suggestedProcedures");
        assertNotNull(retrivedSuggestedProcedures);
        assertEquals("[DefaultHeartAttackProcedure: ]", retrivedSuggestedProcedures.getSuggestedProceduresString());

        Map<String, Object> info = new HashMap<String, Object>();
        SelectedProcedures selectedProcedures = new SelectedProcedures(
                retrivedEmergency.getId());

        selectedProcedures.addSelectedProcedureName("DefaultHeartAttackProcedure");
        info.put("selectedProcedures", selectedProcedures);


        ContentData result = new ContentData();
        result.setAccessType(AccessType.Inline);
        result.setType("java.util.Map");
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bos);
        out.writeObject(info);
        out.close();
        result.setContent(bos.toByteArray());

        BlockingTaskOperationResponseHandler completeTaskOperationHandler = new BlockingTaskOperationResponseHandler();
        client.complete(sums.get(0).getId(), "control", result, completeTaskOperationHandler);



    }

    private void doGarageTask() {
        BlockingTaskSummaryResponseHandler handler = new BlockingTaskSummaryResponseHandler();
        client.getTasksAssignedAsPotentialOwner("garage_emergency_service", "en-UK", handler);
        List<TaskSummary> sums = handler.getResults();
        assertNotNull(sums);
        assertEquals(1, sums.size());

        BlockingTaskOperationResponseHandler startTaskOperationHandler = new BlockingTaskOperationResponseHandler();
        client.start(sums.get(0).getId(), "garage_emergency_service", startTaskOperationHandler);


    }
}