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.api.service.UpdateResult;
  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             if (expectedMonitor.getResult() instanceof UpdateResult){
  97                 UpdateResult result = (UpdateResult)expectedMonitor.getResult();
  98                 if (!result.getExceptions().contains(ise)){
  99                     Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 100                 }
 101             }
 102 //            Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 103         } catch(IllegalStateException e) {
 104
 105         }
 106     }
 107
 108     @Test
 109     public void testMonitLongRunningMethodWithInterrupt() {
 110         IllegalStateException ise = new IllegalStateException("Interrupted Exception");
 111         final UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
 112         final int pollInterval = 1000;
 113         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 114         expectedMonitor.setResult(ise);
 115         expectedMonitor.setCanceled(true);
 116         expectedMonitor.setIsFailed(true);
 117         expectedMonitor.done();
 118
 119         Thread thread = new Thread() {
 120             @Override
 121             public void run() {
 122                 try {
 123                     CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 124                             uuid,
 125                             pollInterval,
 126                             null,
 127                             (IFeedbackGenerator)null,
 128                             new NullProgressMonitor());
 129                     if (expectedMonitor.getResult() instanceof UpdateResult){
 130                         UpdateResult result = (UpdateResult)expectedMonitor.getResult();
 131                         if (!result.getExceptions().contains(ise)){
 132                             Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 133                         }
 134                     }
 135 //                    Assert.fail("InterruptedException wrapped in an IllegalStateException should be thrown");
 136                 } catch (InterruptedException e) {
 137
 138                 } catch (IllegalStateException e) {
 139
 140                 }
 141             }
 142         };
 143         thread.start();
 144         while(!progressMonitorService.isMonitorThreadRunning(uuid)) {}
 145
 146         progressMonitorService.interrupt(uuid);
 147
 148         while(progressMonitorService.isMonitorThreadRunning(uuid)) {}
 149
 150         IRemotingProgressMonitor remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);
 151         new MockPostMoniteredOperationEnabled(expectedMonitor, uuid).postOperation(remotingMonitor);
 152
 153     }
 154
 155     @Test
 156     public void testMonitLongRunningMethodWithCancellation() throws InterruptedException {
 157
 158         final UUID uuid = testService.monitLongRunningMethod(null, null, 0);
 159         final int pollInterval = 1000;
 160         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 161         expectedMonitor.setResult("Cancelled");
 162         expectedMonitor.setCanceled(true);
 163         expectedMonitor.done();
 164
 165         Thread thread = new Thread() {
 166             @Override
 167             public void run() {
 168                 try {
 169                     CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 170                             uuid,
 171                             pollInterval,
 172                             null,
 173                             (IFeedbackGenerator)null,
 174                             new NullProgressMonitor());
 175                 } catch (InterruptedException e) {
 176
 177                 }
 178             }
 179
 180         };
 181         thread.start();
 182         while(!progressMonitorService.isMonitorThreadRunning(uuid)) {}
 183         progressMonitorService.cancel(uuid);
 184         while(progressMonitorService.isMonitorThreadRunning(uuid)) {}
 185         IRemotingProgressMonitor remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);
 186         new MockPostMoniteredOperationEnabled(expectedMonitor, uuid).postOperation(remotingMonitor);
 187
 188     }
 189
 190     @Test
 191     public void testMonitLongRunningMethodWithWaitForFeedback() throws InterruptedException {
 192
 193         List<String> feedbacks = Arrays.asList("feedback1", "feedback2");
 194         List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
 195         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 196         expectedMonitor.setResult("Success");
 197         for(String feedback : feedbacks) {
 198             feebackGenerators.add(new MockFeedbackGenerator(feedback, 0));
 199             expectedMonitor.addReport(feedback);
 200         }
 201         expectedMonitor.addReport("Report");
 202         expectedMonitor.done();
 203
 204         final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 0);
 205         final int pollInterval = 1000;
 206
 207         CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 208                 uuid,
 209                 pollInterval,
 210                 new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
 211                 feebackGenerators,
 212                 new NullProgressMonitor());
 213
 214     }
 215
 216     @Test
 217     public void testMonitLongRunningMethodWithInconsistentWaitForFeedback() throws InterruptedException {
 218
 219         List<String> feedbacks = Arrays.asList("feedback1", "feedback2");
 220         List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
 221         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 222         expectedMonitor.setResult("Success");
 223         for(String feedback : feedbacks) {
 224             feebackGenerators.add(new MockFeedbackGenerator(feedback, 0));
 225             expectedMonitor.addReport(feedback);
 226         }
 227         expectedMonitor.addReport("Report");
 228         expectedMonitor.done();
 229
 230         final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 0);
 231         final int pollInterval = 1000;
 232
 233         feebackGenerators.remove(1);
 234
 235         final UUID newUuid = testService.monitLongRunningMethod(null, feedbacks, 0);
 236
 237         try {
 238             CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 239                     newUuid,
 240                     pollInterval,
 241                     new MockPostMoniteredOperationEnabled(expectedMonitor, newUuid),
 242                     feebackGenerators,
 243                     new NullProgressMonitor());
 244             if (expectedMonitor.getResult() instanceof UpdateResult){
 245                 UpdateResult result = (UpdateResult)expectedMonitor.getResult();
 246                 if (result.getExceptions().isEmpty()){
 247                     Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 248                 }
 249             }
 250 //            Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 251         } catch(IllegalStateException ise) {
 252
 253         }
 254     }
 255
 256     @Test
 257     public void testMonitLongRunningMethodWithWaitForFeedbackTimeout() throws InterruptedException {
 258
 259         List<String> feedbacks = Arrays.asList("feedback1");
 260         List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
 261         final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
 262         expectedMonitor.setResult(new IllegalStateException(new InterruptedException()));
 263         for(String feedback : feedbacks) {
 264             feebackGenerators.add(new MockFeedbackGenerator(feedback, 1000 * 15));
 265
 266         }
 267         expectedMonitor.setCanceled(true);
 268         expectedMonitor.setIsFailed(true);
 269         expectedMonitor.done();
 270
 271         expectedMonitor.done();
 272
 273         final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 1000 * 5);
 274         final int pollInterval = 1000;
 275
 276
 277         try {
 278             CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
 279                     uuid,
 280                     pollInterval,
 281                     new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
 282                     feebackGenerators,
 283                     new NullProgressMonitor());
 284             if (expectedMonitor.getResult() instanceof UpdateResult){
 285                 UpdateResult result = (UpdateResult)expectedMonitor.getResult();
 286                 if (result.getExceptions().isEmpty()){
 287                     Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 288                 }
 289             }
 290 //            Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
 291         } catch(IllegalStateException ise) {
 292
 293         }
 294     }
 295
 296
 297     class MockPostMoniteredOperationEnabled implements IPostMoniteredOperationEnabled {
 298
 299         private RemotingProgressMonitor expectedMonitor;
 300         private UUID monitorUuid;
 301
 302         public MockPostMoniteredOperationEnabled(RemotingProgressMonitor expectedMonitor, UUID monitorUuid) {
 303             this.expectedMonitor = expectedMonitor;
 304             this.monitorUuid = monitorUuid;
 305         }
 306         /**
 307          * {@inheritDoc}
 308          */
 309         @Override
 310         public void postOperation(IRemotingProgressMonitor monitor) {
 311             if(expectedMonitor.getResult() instanceof Exception) {
 312                 Exception expectedException = (Exception) expectedMonitor.getResult();
 313                 Exception exception = (Exception) monitor.getResult();
 314                 Assert.assertEquals(expectedException.getClass(), expectedException.getClass());
 315                 Assert.assertEquals(expectedException.getMessage(), expectedException.getMessage());
 316             } else {
 317                 Assert.assertEquals(expectedMonitor.getResult(), monitor.getResult());
 318             }
 319             Assert.assertEquals(expectedMonitor.getReports(), monitor.getReports());
 320             Assert.assertEquals(expectedMonitor.isCanceled(), monitor.isCanceled());
 321             Assert.assertEquals(expectedMonitor.isFailed(), monitor.isFailed());
 322             Assert.assertEquals(expectedMonitor.isDone(), monitor.isDone());
 323             Assert.assertTrue(!progressMonitorService.isMonitorThreadRunning(monitorUuid));
 324         }
 325     }
 326
 327     class MockFeedbackGenerator implements IFeedbackGenerator {
 328
 329         private String feedback;
 330         private long waitTime;
 331
 332         public MockFeedbackGenerator(String feedback, long waitTime) {
 333             this.feedback = feedback;
 334             this.waitTime = waitTime;
 335         }
 336
 337         /**
 338          * {@inheritDoc}
 339          */
 340         @Override
 341         public void setFeedbackForMonitor(UUID uuid) {
 342             if(waitTime > 0) {
 343                 try {
 344                     Thread.sleep(waitTime);
 345                 } catch (InterruptedException e) {
 346                     e.printStackTrace();
 347                 }
 348             }
 349             CdmApplicationState.getCurrentAppConfig().getProgressMonitorService().setFeedback(uuid, feedback);
 350         }
 351
 352     }
 353 }