EDIT

// $Id$

/**

 * Copyright (C) 2015 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.service;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.junit.After;

import org.junit.Assert;

import org.junit.Test;

import eu.etaxonomy.cdm.api.service.IProgressMonitorService;

import eu.etaxonomy.cdm.api.service.ITestService;

import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.RemotingProgressMonitor;

import eu.etaxonomy.taxeditor.httpinvoker.RemotingSessionAwareTest;

import eu.etaxonomy.taxeditor.operation.IFeedbackGenerator;

import eu.etaxonomy.taxeditor.operation.IPostMoniteredOperationEnabled;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author cmathew

 * @date 22 Oct 2015

 *

 */

public class ProgressMonitorServiceTest extends RemotingSessionAwareTest {

    private static final Logger logger = Logger.getLogger(ProgressMonitorServiceTest.class);

    ITestService testService =  getRemoteApplicationController().getTestService();

    IProgressMonitorService progressMonitorService = getRemoteApplicationController().getProgressMonitorService();

    @After

    public void revertAuthentication() {

        authenticateDefaultUser();

    }

    @Test

    public void testMonitLongRunningMethod() throws InterruptedException {

        UUID uuid = testService.monitLongRunningMethod(null, null);

        int pollInterval = 1000;

        RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult("Success");

        expectedMonitor.addReport("Report");

        expectedMonitor.done();

        CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                uuid,

                pollInterval,

                new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),

                (IFeedbackGenerator)null,

                new NullProgressMonitor());

    }

    @Test

    public void testMonitLongRunningMethodByChangingUser() throws InterruptedException {

        IllegalStateException ise = new IllegalStateException("IllegalStateException");

        UUID uuid = testService.monitLongRunningMethod(ise, null);

        authenticateExtraUser();

        IRemotingProgressMonitor monitor = progressMonitorService.getRemotingMonitor(uuid);

        Assert.assertNull(monitor);

    }

    @Test

    public void testMonitLongRunningMethodWithException() throws InterruptedException {

        IllegalStateException ise = new IllegalStateException("IllegalStateException");

        UUID uuid = testService.monitLongRunningMethod(ise, null);

        int pollInterval = 1000;

        RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult(ise);

        expectedMonitor.setIsFailed(true);

        expectedMonitor.done();

        CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                uuid,

                pollInterval,

                new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),

                (IFeedbackGenerator)null,

                new NullProgressMonitor());

    }

    @Test

    public void testMonitLongRunningMethodWithInterrupt() {

        IllegalStateException ise = new IllegalStateException("Interrupted Exception");

        final UUID uuid = testService.monitLongRunningMethod(ise, null);

        final int pollInterval = 1000;

        final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult(ise);

        expectedMonitor.setCanceled(true);

        expectedMonitor.setIsFailed(true);

        expectedMonitor.done();

        Thread thread = new Thread() {

            @Override

            public void run() {

                try {

                    CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                            uuid,

                            pollInterval,

                            null,

                            (IFeedbackGenerator)null,

                            new NullProgressMonitor());

                } catch (InterruptedException e) {

                }

            }

        };

        thread.start();

        while(!progressMonitorService.isMonitorThreadRunning(uuid)) {}

        progressMonitorService.interrupt(uuid);

        while(progressMonitorService.isMonitorThreadRunning(uuid)) {}

        IRemotingProgressMonitor remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);

        new MockPostMoniteredOperationEnabled(expectedMonitor, uuid).postOperation(remotingMonitor);

    }

    @Test

    public void testMonitLongRunningMethodWithCancellation() throws InterruptedException {

        final UUID uuid = testService.monitLongRunningMethod(null, null);

        final int pollInterval = 1000;

        final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult("Cancelled");

        expectedMonitor.setCanceled(true);

        expectedMonitor.done();

        Thread thread = new Thread() {

            @Override

            public void run() {

                try {

                    CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                            uuid,

                            pollInterval,

                            null,

                            (IFeedbackGenerator)null,

                            new NullProgressMonitor());

                } catch (InterruptedException e) {

                }

            }

        };

        thread.start();

        while(!progressMonitorService.isMonitorThreadRunning(uuid)) {}

        progressMonitorService.cancel(uuid);

        while(progressMonitorService.isMonitorThreadRunning(uuid)) {}

        IRemotingProgressMonitor remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);

        new MockPostMoniteredOperationEnabled(expectedMonitor, uuid).postOperation(remotingMonitor);

    }

    @Test

    public void testMonitLongRunningMethodWithWaitForFeedback() throws InterruptedException {

        List<String> feedbacks = Arrays.asList("feedback1", "feedback2");

        List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();

        final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult("Success");

        for(String feedback : feedbacks) {

            feebackGenerators.add(new MockFeedbackGenerator(feedback));

            expectedMonitor.addReport(feedback);

        }

        expectedMonitor.addReport("Report");

        expectedMonitor.done();

        final UUID uuid = testService.monitLongRunningMethod(null, feedbacks);

        final int pollInterval = 1000;

        CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                uuid,

                pollInterval,

                new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),

                feebackGenerators,

                new NullProgressMonitor());

        feebackGenerators.remove(1);

        final UUID newUuid = testService.monitLongRunningMethod(null, feedbacks);

        try {

            CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                    newUuid,

                    pollInterval,

                    new MockPostMoniteredOperationEnabled(expectedMonitor, newUuid),

                    feebackGenerators,

                    new NullProgressMonitor());

            Assert.fail("Exception due to inconsistent number of feedback generators not thrown");

        } catch(IllegalStateException ise) {

        }

    }

    class MockPostMoniteredOperationEnabled implements IPostMoniteredOperationEnabled {

        private RemotingProgressMonitor expectedMonitor;

        private UUID monitorUuid;

        public MockPostMoniteredOperationEnabled(RemotingProgressMonitor expectedMonitor, UUID monitorUuid) {

            this.expectedMonitor = expectedMonitor;

            this.monitorUuid = monitorUuid;

        }

        /**

         * {@inheritDoc}

         */

        @Override

        public void postOperation(IRemotingProgressMonitor monitor) {

            if(expectedMonitor.getResult() instanceof Exception) {

                Exception expectedException = (Exception) expectedMonitor.getResult();

                Exception exception = (Exception) monitor.getResult();

                Assert.assertEquals(expectedException.getClass(), expectedException.getClass());

                Assert.assertEquals(expectedException.getMessage(), expectedException.getMessage());

            } else {

                Assert.assertEquals(expectedMonitor.getResult(), monitor.getResult());

            }

            Assert.assertEquals(expectedMonitor.getReports(), monitor.getReports());

            Assert.assertEquals(expectedMonitor.isCanceled(), monitor.isCanceled());

            Assert.assertEquals(expectedMonitor.isFailed(), monitor.isFailed());

            Assert.assertEquals(expectedMonitor.isDone(), monitor.isDone());

            Assert.assertTrue(!progressMonitorService.isMonitorThreadRunning(monitorUuid));

        }

    }

    class MockFeedbackGenerator implements IFeedbackGenerator {

        private String feedback;

        public MockFeedbackGenerator(String feedback) {

            this.feedback = feedback;

        }

        /**

         * {@inheritDoc}

         */

        @Override

        public Serializable generateFeedback() {

            return feedback;

        }

    }

}