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