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

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