eu.etaxonomy.taxeditor.test/src/test/java/eu/etaxonomy/taxeditor/service/ProgressMonitorServiceTest.java

   1 /**
   2  * Copyright (C) 2015 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9 package eu.etaxonomy.taxeditor.service;
  10
  11 import java.util.ArrayList;
  12 import java.util.Arrays;
  13 import java.util.List;
  14 import java.util.UUID;
  15
  16 import org.apache.log4j.Logger;
  17 import org.eclipse.core.runtime.NullProgressMonitor;
  18 import org.junit.After;
  19 import org.junit.Assert;
  20 import org.junit.Test;
  21
  22 import eu.etaxonomy.cdm.api.application.CdmApplicationState;
  23 import eu.etaxonomy.cdm.api.service.IProgressMonitorService;
  24 import eu.etaxonomy.cdm.api.service.ITestService;
  25 import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
  26 import eu.etaxonomy.cdm.common.monitor.RemotingProgressMonitor;
  27 import eu.etaxonomy.taxeditor.httpinvoker.RemotingSessionAwareTest;
  28 import eu.etaxonomy.taxeditor.operation.IFeedbackGenerator;
  29 import eu.etaxonomy.taxeditor.operation.IPostMoniteredOperationEnabled;
  30 import eu.etaxonomy.taxeditor.store.CdmStore;
  31
  32 /**
  33  * @author cmathew
  34  * @date 22 Oct 2015
  35  *
  36  */
  37 public class ProgressMonitorServiceTest extends RemotingSessionAwareTest {
  38
  39     private static final Logger logger = Logger.getLogger(ProgressMonitorServiceTest.class);
  40
  41     ITestService testService =  getRemoteApplicationController().getTestService();
  42
  43     IProgressMonitorService progressMonitorService = getRemoteApplicationController().getProgressMonitorService();
  44
  45
  46
  47     @After
  48     public void revertAuthentication() {
  49         authenticateDefaultUser();
  50     }
  51
  52     @Test
  53     public void testMonitLongRunningMethod() throws InterruptedException {
  54         UUID uuid = testService.monitLongRunningMethod(null, null, 0);
  55         int pollInterval = 1000;
  56         RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
  57         expectedMonitor.setResult("Success");
  58         expectedMonitor.addReport("Report");
  59         expectedMonitor.done();
  60         CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
  61                 uuid,
  62                 pollInterval,
  63                 new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
  64                 (IFeedbackGenerator)null,
  65                 new NullProgressMonitor());
  66     }
  67
  68     @Test
  69     public void testMonitLongRunningMethodByChangingUser() throws InterruptedException {
  70
  71         IllegalStateException ise = new IllegalStateException("IllegalStateException");
  72         UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
  73         authenticateExtraUser();
  74         IRemotingProgressMonitor monitor = progressMonitorService.getRemotingMonitor(uuid);
  75         Assert.assertNull(monitor);
  76
  77     }
  78
  79     @Test
  80     public void testMonitLongRunningMethodWithException() throws InterruptedException {
  81         IllegalStateException ise = new IllegalStateException("IllegalStateException");
  82         UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
  83         int pollInterval = 1000;
  84         RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
  85         expectedMonitor.setResult(ise);
  86         expectedMonitor.setIsFailed(true);
  87         expectedMonitor.done();
  88         try {
  89             CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
  90                     uuid,
  91                     pollInterval,
  92                     new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
  93                     (IFeedbackGenerator)null,
  94                     new NullProgressMonitor());
  95             Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
  96         } catch(IllegalStateException e) {
  97
  98         }
  99     }
 100
 101     @Test
 102     public void testMonitLongRunningMethodWithInterrupt() {
 103         IllegalStateException ise = new IllegalStateException("Interrupted Exception");
 104         final UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
 105         final int pollInterval = 1000;
 106         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 107         expectedMonitor.setResult(ise);
 108         expectedMonitor.setCanceled(true);
 109         expectedMonitor.setIsFailed(true);
 110         expectedMonitor.done();
 111
 112         Thread thread = new Thread() {
 113             @Override
 114             public void run() {
 115                 try {
 116                     CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 117                             uuid,
 118                             pollInterval,
 119                             null,
 120                             (IFeedbackGenerator)null,
 121                             new NullProgressMonitor());
 122                     Assert.fail("InterruptedException wrapped in an IllegalStateException should be thrown");
 123                 } catch (InterruptedException e) {
 124
 125                 } catch (IllegalStateException e) {
 126
 127                 }
 128             }
 129         };
 130         thread.start();
 131         while(!progressMonitorService.isMonitorThreadRunning(uuid)) {}
 132
 133         progressMonitorService.interrupt(uuid);
 134
 135         while(progressMonitorService.isMonitorThreadRunning(uuid)) {}
 136
 137         IRemotingProgressMonitor remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);
 138         new MockPostMoniteredOperationEnabled(expectedMonitor, uuid).postOperation(remotingMonitor);
 139
 140     }
 141
 142     @Test
 143     public void testMonitLongRunningMethodWithCancellation() throws InterruptedException {
 144
 145         final UUID uuid = testService.monitLongRunningMethod(null, null, 0);
 146         final int pollInterval = 1000;
 147         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 148         expectedMonitor.setResult("Cancelled");
 149         expectedMonitor.setCanceled(true);
 150         expectedMonitor.done();
 151
 152         Thread thread = new Thread() {
 153             @Override
 154             public void run() {
 155                 try {
 156                     CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 157                             uuid,
 158                             pollInterval,
 159                             null,
 160                             (IFeedbackGenerator)null,
 161                             new NullProgressMonitor());
 162                 } catch (InterruptedException e) {
 163
 164                 }
 165             }
 166
 167         };
 168         thread.start();
 169         while(!progressMonitorService.isMonitorThreadRunning(uuid)) {}
 170         progressMonitorService.cancel(uuid);
 171         while(progressMonitorService.isMonitorThreadRunning(uuid)) {}
 172         IRemotingProgressMonitor remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);
 173         new MockPostMoniteredOperationEnabled(expectedMonitor, uuid).postOperation(remotingMonitor);
 174
 175     }
 176
 177     @Test
 178     public void testMonitLongRunningMethodWithWaitForFeedback() throws InterruptedException {
 179
 180         List<String> feedbacks = Arrays.asList("feedback1", "feedback2");
 181         List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
 182         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 183         expectedMonitor.setResult("Success");
 184         for(String feedback : feedbacks) {
 185             feebackGenerators.add(new MockFeedbackGenerator(feedback, 0));
 186             expectedMonitor.addReport(feedback);
 187         }
 188         expectedMonitor.addReport("Report");
 189         expectedMonitor.done();
 190
 191         final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 0);
 192         final int pollInterval = 1000;
 193
 194         CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 195                 uuid,
 196                 pollInterval,
 197                 new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
 198                 feebackGenerators,
 199                 new NullProgressMonitor());
 200
 201     }
 202
 203     @Test
 204     public void testMonitLongRunningMethodWithInconsistentWaitForFeedback() throws InterruptedException {
 205
 206         List<String> feedbacks = Arrays.asList("feedback1", "feedback2");
 207         List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
 208         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 209         expectedMonitor.setResult("Success");
 210         for(String feedback : feedbacks) {
 211             feebackGenerators.add(new MockFeedbackGenerator(feedback, 0));
 212             expectedMonitor.addReport(feedback);
 213         }
 214         expectedMonitor.addReport("Report");
 215         expectedMonitor.done();
 216
 217         final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 0);
 218         final int pollInterval = 1000;
 219
 220         feebackGenerators.remove(1);
 221
 222         final UUID newUuid = testService.monitLongRunningMethod(null, feedbacks, 0);
 223
 224         try {
 225             CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 226                     newUuid,
 227                     pollInterval,
 228                     new MockPostMoniteredOperationEnabled(expectedMonitor, newUuid),
 229                     feebackGenerators,
 230                     new NullProgressMonitor());
 231             Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 232         } catch(IllegalStateException ise) {
 233
 234         }
 235     }
 236
 237     @Test
 238     public void testMonitLongRunningMethodWithWaitForFeedbackTimeout() throws InterruptedException {
 239
 240         List<String> feedbacks = Arrays.asList("feedback1");
 241         List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
 242         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 243         expectedMonitor.setResult(new IllegalStateException(new InterruptedException()));
 244         for(String feedback : feedbacks) {
 245             feebackGenerators.add(new MockFeedbackGenerator(feedback, 1000 * 15));
 246
 247         }
 248         expectedMonitor.setCanceled(true);
 249         expectedMonitor.setIsFailed(true);
 250         expectedMonitor.done();
 251
 252         expectedMonitor.done();
 253
 254         final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 1000 * 5);
 255         final int pollInterval = 1000;
 256
 257
 258         try {
 259             CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 260                     uuid,
 261                     pollInterval,
 262                     new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
 263                     feebackGenerators,
 264                     new NullProgressMonitor());
 265             Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 266         } catch(IllegalStateException ise) {
 267
 268         }
 269     }
 270
 271
 272     class MockPostMoniteredOperationEnabled implements IPostMoniteredOperationEnabled {
 273
 274         private RemotingProgressMonitor expectedMonitor;
 275         private UUID monitorUuid;
 276
 277         public MockPostMoniteredOperationEnabled(RemotingProgressMonitor expectedMonitor, UUID monitorUuid) {
 278             this.expectedMonitor = expectedMonitor;
 279             this.monitorUuid = monitorUuid;
 280         }
 281         /**
 282          * {@inheritDoc}
 283          */
 284         @Override
 285         public void postOperation(IRemotingProgressMonitor monitor) {
 286             if(expectedMonitor.getResult() instanceof Exception) {
 287                 Exception expectedException = (Exception) expectedMonitor.getResult();
 288                 Exception exception = (Exception) monitor.getResult();
 289                 Assert.assertEquals(expectedException.getClass(), expectedException.getClass());
 290                 Assert.assertEquals(expectedException.getMessage(), expectedException.getMessage());
 291             } else {
 292                 Assert.assertEquals(expectedMonitor.getResult(), monitor.getResult());
 293             }
 294             Assert.assertEquals(expectedMonitor.getReports(), monitor.getReports());
 295             Assert.assertEquals(expectedMonitor.isCanceled(), monitor.isCanceled());
 296             Assert.assertEquals(expectedMonitor.isFailed(), monitor.isFailed());
 297             Assert.assertEquals(expectedMonitor.isDone(), monitor.isDone());
 298             Assert.assertTrue(!progressMonitorService.isMonitorThreadRunning(monitorUuid));
 299         }
 300     }
 301
 302     class MockFeedbackGenerator implements IFeedbackGenerator {
 303
 304         private String feedback;
 305         private long waitTime;
 306
 307         public MockFeedbackGenerator(String feedback, long waitTime) {
 308             this.feedback = feedback;
 309             this.waitTime = waitTime;
 310         }
 311
 312         /**
 313          * {@inheritDoc}
 314          */
 315         @Override
 316         public void setFeedbackForMonitor(UUID uuid) {
 317             if(waitTime > 0) {
 318                 try {
 319                     Thread.sleep(waitTime);
 320                 } catch (InterruptedException e) {
 321                     e.printStackTrace();
 322                 }
 323             }
 324             CdmApplicationState.getCurrentAppConfig().getProgressMonitorService().setFeedback(uuid, feedback);
 325         }
 326
 327     }
 328 }