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.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.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);

        int pollInterval = 1000;

        RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult("Success");

        expectedMonitor.addReport("Report");

        expectedMonitor.done();

        IRemotingProgressMonitor remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                uuid,

                pollInterval,

                new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),

                new NullProgressMonitor());

    }

    @Test

    public void testMonitLongRunningMethodByChangingUser() throws InterruptedException {

        IllegalStateException ise = new IllegalStateException("IllegalStateException");

        UUID uuid = testService.monitLongRunningMethod(ise);

        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);

        int pollInterval = 1000;

        RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();

        expectedMonitor.setResult(ise);

        expectedMonitor.setIsFailed(true);

        expectedMonitor.done();

        IRemotingProgressMonitor remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                uuid,

                pollInterval,

                new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),

                new NullProgressMonitor());

    }

    @Test

    public void testMonitLongRunningMethodWithInterrupt() throws InterruptedException {

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

        final UUID uuid = testService.monitLongRunningMethod(ise);

        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 {

                    IRemotingProgressMonitor remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                            uuid,

                            pollInterval,

                            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);

        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 {

                    IRemotingProgressMonitor remotingMonitor = CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",

                            uuid,

                            pollInterval,

                            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);

    }

    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));

        }

    }

}